1.1 --- a/src/share/classes/java/dyn/CallSite.java Tue Jan 05 10:40:44 2010 +0800
1.2 +++ b/src/share/classes/java/dyn/CallSite.java Wed Jan 13 15:16:06 2010 -0800
1.3 @@ -26,6 +26,9 @@
1.4 package java.dyn;
1.5
1.6 import sun.dyn.util.BytecodeName;
1.7 +import sun.dyn.Access;
1.8 +import sun.dyn.CallSiteImpl;
1.9 +import sun.dyn.MethodHandleImpl;
1.10
1.11 /**
1.12 * An {@code invokedynamic} call site, as reified by the
1.13 @@ -52,15 +55,25 @@
1.14 * @see Linkage#registerBootstrapMethod(java.lang.Class, java.dyn.MethodHandle)
1.15 * @author John Rose, JSR 292 EG
1.16 */
1.17 -public class CallSite {
1.18 +public class CallSite
1.19 + // Note: This is an implementation inheritance hack, and will be removed
1.20 + // with a JVM change which moves the required hidden state onto this class.
1.21 + extends CallSiteImpl
1.22 +{
1.23 + private static final Access IMPL_TOKEN = Access.getToken();
1.24 +
1.25 + /*
1.26 +
1.27 // Fields used only by the JVM. Do not use or change.
1.28 private Object vmmethod;
1.29 int callerMID, callerBCI; // supplied by the JVM
1.30
1.31 - MethodHandle target;
1.32 + private MethodHandle target;
1.33 +
1.34 final Object caller; // usually a class
1.35 final String name;
1.36 final MethodType type;
1.37 + */
1.38
1.39 /**
1.40 * Make a call site given the parameters from a call to the bootstrap method.
1.41 @@ -72,16 +85,21 @@
1.42 * @param type the method handle type derived from descriptor of the {@code invokedynamic} instruction
1.43 */
1.44 public CallSite(Object caller, String name, MethodType type) {
1.45 - this.caller = caller;
1.46 - this.name = name;
1.47 - this.type = type;
1.48 + super(IMPL_TOKEN, caller, name, type);
1.49 }
1.50
1.51 private static void privateInitializeCallSite(CallSite site, int callerMID, int callerBCI) {
1.52 site.callerMID = callerMID;
1.53 site.callerBCI = callerBCI;
1.54 - if (site.target == null)
1.55 - site.setTarget(site.initialTarget());
1.56 + site.ensureTarget();
1.57 + }
1.58 + private void ensureTarget() {
1.59 + // Note use of super, which accesses the field directly,
1.60 + // without deferring to possible subclass overrides.
1.61 + if (super.getTarget() == null) {
1.62 + super.setTarget(this.initialTarget());
1.63 + super.getTarget().type(); // provoke NPE if still null
1.64 + }
1.65 }
1.66
1.67 /**
1.68 @@ -102,10 +120,11 @@
1.69
1.70 /**
1.71 * Report the current linkage state of the call site. (This is mutable.)
1.72 - * The value maybe null only if the call site is currently unlinked.
1.73 - * When a linked call site is invoked, the target method is used directly.
1.74 - * When an unlinked call site is invoked, its bootstrap method receives
1.75 - * the call, as if via {@link Linkage#bootstrapInvokeDynamic}.
1.76 + * The value may not be null after the {@code CallSite} object is returned
1.77 + * from the bootstrap method of the {@code invokedynamic} instruction.
1.78 + * When an {@code invokedynamic} instruction is executed, the target method
1.79 + * of its associated {@code call site} object is invoked directly,
1.80 + * as if via {@link MethodHandle}{@code .invoke}.
1.81 * <p>
1.82 * The interactions of {@code getTarget} with memory are the same
1.83 * as of a read from an ordinary variable, such as an array element or a
1.84 @@ -118,7 +137,7 @@
1.85 * @see #setTarget
1.86 */
1.87 public MethodHandle getTarget() {
1.88 - return target;
1.89 + return super.getTarget();
1.90 }
1.91
1.92 /**
1.93 @@ -140,13 +159,13 @@
1.94 */
1.95 public void setTarget(MethodHandle target) {
1.96 checkTarget(target);
1.97 - this.target = target;
1.98 + super.setTarget(target);
1.99 }
1.100
1.101 protected void checkTarget(MethodHandle target) {
1.102 target.type(); // provoke NPE
1.103 if (!canSetTarget(target))
1.104 - throw new WrongMethodTypeException(String.valueOf(target));
1.105 + throw new WrongMethodTypeException(String.valueOf(target)+target.type()+" should be of type "+type());
1.106 }
1.107
1.108 protected boolean canSetTarget(MethodHandle target) {
1.109 @@ -219,6 +238,10 @@
1.110
1.111 @Override
1.112 public String toString() {
1.113 - return "CallSite#"+hashCode()+"["+name+type+" => "+target+"]";
1.114 + return "CallSite#"+hashCode()+"["+name+type+" => "+getTarget()+"]";
1.115 }
1.116 +
1.117 + // Package-local constant:
1.118 + static final MethodHandle GET_TARGET = MethodHandleImpl.getLookup(IMPL_TOKEN).
1.119 + findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class));
1.120 }
2.1 --- a/src/share/classes/java/dyn/InvokeDynamic.java Tue Jan 05 10:40:44 2010 +0800
2.2 +++ b/src/share/classes/java/dyn/InvokeDynamic.java Wed Jan 13 15:16:06 2010 -0800
2.3 @@ -45,6 +45,24 @@
2.4 * class or interface supertype, or an object type; it can never be instantiated.
2.5 * Logically, it denotes a source of all dynamically typed methods.
2.6 * It may be viewed as a pure syntactic marker (an importable one) of static calls.
2.7 + * <p>
2.8 + * Here are some examples of usage:
2.9 + * <p><blockquote><pre>
2.10 + * Object x; String s; int i;
2.11 + * x = InvokeDynamic.greet("world"); // greet(Ljava/lang/String;)Ljava/lang/Object;
2.12 + * s = InvokeDynamic.<String>hail(x); // hail(Ljava/lang/Object;)Ljava/lang/String;
2.13 + * InvokeDynamic.<void>cogito(); // cogito()V
2.14 + * i = InvokeDynamic.<int>#"op:+"(2, 3); // "op:+"(II)I
2.15 + * </pre></blockquote>
2.16 + * Each of the above calls generates a single invokedynamic instruction
2.17 + * with the name-and-type descriptors indicated in the comments.
2.18 + * The argument types are taken directly from the actual arguments,
2.19 + * while the return type is taken from the type parameter.
2.20 + * (This type parameter may be a primtive, and it defaults to {@code Object}.)
2.21 + * The final example uses a special syntax for uttering non-Java names.
2.22 + * Any name legal to the JVM may be given between the double quotes.
2.23 + * None of these calls is complete without a bootstrap method,
2.24 + * which must be registered by the static initializer of the enclosing class.
2.25 * @author John Rose, JSR 292 EG
2.26 */
2.27 public final class InvokeDynamic {
3.1 --- a/src/share/classes/java/dyn/InvokeDynamicBootstrapError.java Tue Jan 05 10:40:44 2010 +0800
3.2 +++ b/src/share/classes/java/dyn/InvokeDynamicBootstrapError.java Wed Jan 13 15:16:06 2010 -0800
3.3 @@ -52,4 +52,16 @@
3.4 public InvokeDynamicBootstrapError(String s) {
3.5 super(s);
3.6 }
3.7 +
3.8 + /**
3.9 + * Constructs a {@code InvokeDynamicBootstrapError} with the specified
3.10 + * detail message and cause.
3.11 + *
3.12 + * @param s the detail message.
3.13 + * @param cause the cause.
3.14 + */
3.15 + public InvokeDynamicBootstrapError(String s, Throwable cause) {
3.16 + super(s);
3.17 + this.initCause(cause);
3.18 + }
3.19 }
4.1 --- a/src/share/classes/java/dyn/JavaMethodHandle.java Tue Jan 05 10:40:44 2010 +0800
4.2 +++ b/src/share/classes/java/dyn/JavaMethodHandle.java Wed Jan 13 15:16:06 2010 -0800
4.3 @@ -25,6 +25,8 @@
4.4
4.5 package java.dyn;
4.6
4.7 +import sun.dyn.Access;
4.8 +
4.9 /**
4.10 * A Java method handle extends the basic method handle type with additional
4.11 * programmer defined methods and fields.
4.12 @@ -39,31 +41,105 @@
4.13 * of the entry point method handle, with the leading parameter type
4.14 * omitted.
4.15 * <p>
4.16 - * Here is an example of usage:
4.17 + * Here is an example of usage, creating a hybrid object/functional datum:
4.18 * <p><blockquote><pre>
4.19 - * class Greeter extends JavaMethodHandle {
4.20 + * class Greeter extends JavaMethodHandle {
4.21 + * private String greeting = "hello";
4.22 + * public void setGreeting(String s) { greeting = s; }
4.23 + * public void run() { System.out.println(greeting+", "+greetee); }
4.24 + * private final String greetee;
4.25 + * Greeter(String greetee) {
4.26 + * super(RUN); // alternatively, super("run")
4.27 + * this.greetee = greetee;
4.28 + * }
4.29 + * // the entry point function is computed once:
4.30 + * private static final MethodHandle RUN
4.31 + * = MethodHandles.lookup().findVirtual(Greeter.class, "run",
4.32 + * MethodType.make(void.class));
4.33 + * }
4.34 + * // class Main { public static void main(String... av) { ...
4.35 + * Greeter greeter = new Greeter("world");
4.36 + * greeter.run(); // prints "hello, world"
4.37 + * // Statically typed method handle invocation (most direct):
4.38 + * MethodHandle mh = greeter;
4.39 + * mh.<void>invoke(); // also prints "hello, world"
4.40 + * // Dynamically typed method handle invocation:
4.41 + * MethodHandles.invoke(greeter); // also prints "hello, world"
4.42 + * greeter.setGreeting("howdy");
4.43 + * mh.invoke(); // prints "howdy, world" (object-like mutable behavior)
4.44 + * </pre></blockquote>
4.45 + * <p>
4.46 + * In the example of {@code Greeter}, the method {@code run} provides the entry point.
4.47 + * The entry point need not be a constant value; it may be independently
4.48 + * computed in each call to the constructor. The entry point does not
4.49 + * even need to be a method on the {@code Greeter} class, though
4.50 + * that is the typical case.
4.51 + * <p>
4.52 + * The entry point may also be provided symbolically, in which case the the
4.53 + * {@code JavaMethodHandle} constructor performs the lookup of the entry point.
4.54 + * This makes it possible to use {@code JavaMethodHandle} to create an anonymous
4.55 + * inner class:
4.56 + * <p><blockquote><pre>
4.57 + * // We can also do this with symbolic names and/or inner classes:
4.58 + * MethodHandles.invoke(new JavaMethodHandle("yow") {
4.59 + * void yow() { System.out.println("yow, world"); }
4.60 + * });
4.61 + * </pre></blockquote>
4.62 + * <p>
4.63 + * Here is similar lower-level code which works in terms of a bound method handle.
4.64 + * <p><blockquote><pre>
4.65 + * class Greeter {
4.66 * public void run() { System.out.println("hello, "+greetee); }
4.67 * private final String greetee;
4.68 - * Greeter(String greetee) {
4.69 - * super(RUN);
4.70 - * this.greetee = greetee;
4.71 - * }
4.72 + * Greeter(String greetee) { this.greetee = greetee; }
4.73 * // the entry point function is computed once:
4.74 * private static final MethodHandle RUN
4.75 - * = MethodHandles.findVirtual(MyMethodHandle.class, "run",
4.76 + * = MethodHandles.findVirtual(Greeter.class, "run",
4.77 * MethodType.make(void.class));
4.78 * }
4.79 + * // class Main { public static void main(String... av) { ...
4.80 * Greeter greeter = new Greeter("world");
4.81 * greeter.run(); // prints "hello, world"
4.82 - * MethodHandle mh = greeter;
4.83 + * MethodHandle mh = MethodHanndles.insertArgument(Greeter.RUN, 0, greeter);
4.84 * mh.invoke(); // also prints "hello, world"
4.85 * </pre></blockquote>
4.86 + * Note that the method handle must be separately created as a view on the base object.
4.87 + * This increases footprint, complexity, and dynamic indirections.
4.88 * <p>
4.89 - * In this example, the method {@code run} provides the entry point.
4.90 - * The entry point need not be a constant value; it may be independently
4.91 - * computed in each call to the constructor. The entry point does not
4.92 - * even need to be a method on the Java method handle class, though
4.93 - * that is the typical case.
4.94 + * Here is a pure functional value expressed most concisely as an anonymous inner class:
4.95 + * <p><blockquote><pre>
4.96 + * // class Main { public static void main(String... av) { ...
4.97 + * final String greetee = "world";
4.98 + * MethodHandle greeter = new JavaMethodHandle("run") {
4.99 + * private void run() { System.out.println("hello, "+greetee); }
4.100 + * }
4.101 + * greeter.invoke(); // prints "hello, world"
4.102 + * </pre></blockquote>
4.103 + * <p>
4.104 + * Here is an abstract parameterized lvalue, efficiently expressed as a subtype of MethodHandle,
4.105 + * and instantiated as an anonymous class. The data structure is a handle to 1-D array,
4.106 + * with a specialized index type (long). It is created by inner class, and uses
4.107 + * signature-polymorphic APIs throughout.
4.108 + * <p><blockquote><pre>
4.109 + * abstract class AssignableMethodHandle extends JavaMethodHandle {
4.110 + * private final MethodHandle setter;
4.111 + * public MethodHandle setter() { return setter; }
4.112 + * public AssignableMethodHandle(String get, String set) {
4.113 + * super(get);
4.114 + * MethodType getType = this.type();
4.115 + * MethodType setType = getType.insertParameterType(getType.parameterCount(), getType.returnType()).changeReturnType(void.class);
4.116 + * this.setter = MethodHandles.publicLookup().bind(this, set, setType);
4.117 + * }
4.118 + * }
4.119 + * // class Main { public static void main(String... av) { ...
4.120 + * final Number[] stuff = { 123, 456 };
4.121 + * AssignableMethodHandle stuffPtr = new AssignableMethodHandle("get", "set") {
4.122 + * public Number get(long i) { return stuff[(int)i]; }
4.123 + * public void set(long i, Object x) { stuff[(int)i] = x; }
4.124 + * }
4.125 + * int x = (Integer) stuffPtr.<Number>invoke(1L); // 456
4.126 + * stuffPtr.setter().<void>invoke(0L, (Number) 789); // replaces 123 with 789
4.127 + * </pre></blockquote>
4.128 * @see MethodHandle
4.129 * @author John Rose, JSR 292 EG
4.130 */
4.131 @@ -72,12 +148,87 @@
4.132 // with a JVM change which moves the required hidden behavior onto this class.
4.133 extends sun.dyn.BoundMethodHandle
4.134 {
4.135 + private static final Access IMPL_TOKEN = Access.getToken();
4.136 +
4.137 /**
4.138 - * When creating a, pass in {@code entryPoint}, any method handle which
4.139 - * can take the current object
4.140 - * @param entryPoint
4.141 + * When creating a {@code JavaMethodHandle}, the actual method handle
4.142 + * invocation behavior will be delegated to the specified {@code entryPoint}.
4.143 + * This may be any method handle which can take the newly constructed object
4.144 + * as a leading parameter.
4.145 + * <p>
4.146 + * The method handle type of {@code this} (i.e, the fully constructed object)
4.147 + * will be {@code entryPoint}, minus the leading argument.
4.148 + * The leading argument will be bound to {@code this} on every method
4.149 + * handle invocation.
4.150 + * @param entryPoint the method handle to handle calls
4.151 */
4.152 protected JavaMethodHandle(MethodHandle entryPoint) {
4.153 - super(entryPoint, 0);
4.154 + super(entryPoint);
4.155 + }
4.156 +
4.157 + /**
4.158 + * Create a method handle whose entry point is a non-static method
4.159 + * visible in the exact (most specific) class of
4.160 + * the newly constructed object.
4.161 + * <p>
4.162 + * The method is specified by name and type, as if via this expression:
4.163 + * {@code MethodHandles.lookup().findVirtual(this.getClass(), name, type)}.
4.164 + * The class defining the method might be an anonymous inner class.
4.165 + * <p>
4.166 + * The method handle type of {@code this} (i.e, the fully constructed object)
4.167 + * will be the given method handle type.
4.168 + * A call to {@code this} will invoke the selected method.
4.169 + * The receiver argument will be bound to {@code this} on every method
4.170 + * handle invocation.
4.171 + * <p>
4.172 + * <i>Rationale:</i>
4.173 + * Although this constructor may seem to be a mere luxury,
4.174 + * it is not subsumed by the more general constructor which
4.175 + * takes any {@code MethodHandle} as the entry point argument.
4.176 + * In order to convert an entry point name to a method handle,
4.177 + * the self-class of the object is required (in order to do
4.178 + * the lookup). The self-class, in turn, is generally not
4.179 + * available at the time of the constructor invocation,
4.180 + * due to the rules of Java and the JVM verifier.
4.181 + * One cannot call {@code this.getClass()}, because
4.182 + * the value of {@code this} is inaccessible at the point
4.183 + * of the constructor call. (Changing this would require
4.184 + * change to the Java language, verifiers, and compilers.)
4.185 + * In particular, this constructor allows {@code JavaMethodHandle}s
4.186 + * to be created in combination with the anonymous inner class syntax.
4.187 + * @param entryPointName the name of the entry point method
4.188 + * @param type (optional) the desired type of the method handle
4.189 + */
4.190 + protected JavaMethodHandle(String entryPointName, MethodType type) {
4.191 + super(entryPointName, type, true);
4.192 +
4.193 + }
4.194 +
4.195 + /**
4.196 + * Create a method handle whose entry point is a non-static method
4.197 + * visible in the exact (most specific) class of
4.198 + * the newly constructed object.
4.199 + * <p>
4.200 + * The method is specified only by name.
4.201 + * There must be exactly one method of that name visible in the object class,
4.202 + * either inherited or locally declared.
4.203 + * (That is, the method must not be overloaded.)
4.204 + * <p>
4.205 + * The method handle type of {@code this} (i.e, the fully constructed object)
4.206 + * will be the same as the type of the selected non-static method.
4.207 + * The receiver argument will be bound to {@code this} on every method
4.208 + * handle invocation.
4.209 + * <p>ISSUE: This signature wildcarding feature does not correspond to
4.210 + * any MethodHandles.Lookup API element. Can we eliminate it?
4.211 + * Alternatively, it is useful for naming non-overloaded methods.
4.212 + * Shall we make type arguments optional in the Lookup methods,
4.213 + * throwing an error in cases of ambiguity?
4.214 + * <p>
4.215 + * For this method's rationale, see the documentation
4.216 + * for {@link #JavaMethodHandle(String,MethodType)}.
4.217 + * @param entryPointName the name of the entry point method
4.218 + */
4.219 + protected JavaMethodHandle(String entryPointName) {
4.220 + super(entryPointName, (MethodType) null, false);
4.221 }
4.222 }
5.1 --- a/src/share/classes/java/dyn/Linkage.java Tue Jan 05 10:40:44 2010 +0800
5.2 +++ b/src/share/classes/java/dyn/Linkage.java Wed Jan 13 15:16:06 2010 -0800
5.3 @@ -25,7 +25,9 @@
5.4
5.5 package java.dyn;
5.6
5.7 +import java.dyn.MethodHandles.Lookup;
5.8 import java.util.WeakHashMap;
5.9 +import sun.dyn.Access;
5.10 import sun.reflect.Reflection;
5.11 import static sun.dyn.util.VerifyAccess.checkBootstrapPrivilege;
5.12
5.13 @@ -34,6 +36,8 @@
5.14 * @author John Rose, JSR 292 EG
5.15 */
5.16 public class Linkage {
5.17 + private static final Access IMPL_TOKEN = Access.getToken();
5.18 +
5.19 private Linkage() {} // do not instantiate
5.20
5.21 /**
5.22 @@ -53,19 +57,23 @@
5.23 * call to this method.
5.24 * <li>The given class is already fully initialized.
5.25 * <li>The given class is in the process of initialization, in another thread.
5.26 + * <li>The same {@code CallSite} object has already been returned from
5.27 + * a bootstrap method call to another {@code invokedynamic} call site.
5.28 * </ul>
5.29 * Because of these rules, a class may install its own bootstrap method in
5.30 * a static initializer.
5.31 + * @param callerClass a class that may have {@code invokedynamic} sites
5.32 + * @param bootstrapMethod the method to use to bootstrap all such sites
5.33 */
5.34 public static
5.35 - void registerBootstrapMethod(Class callerClass, MethodHandle mh) {
5.36 + void registerBootstrapMethod(Class callerClass, MethodHandle bootstrapMethod) {
5.37 Class callc = Reflection.getCallerClass(2);
5.38 checkBootstrapPrivilege(callc, callerClass, "registerBootstrapMethod");
5.39 - checkBSM(mh);
5.40 + checkBSM(bootstrapMethod);
5.41 synchronized (bootstrapMethods) {
5.42 if (bootstrapMethods.containsKey(callerClass))
5.43 throw new IllegalStateException("bootstrap method already declared in "+callerClass);
5.44 - bootstrapMethods.put(callerClass, mh);
5.45 + bootstrapMethods.put(callerClass, bootstrapMethod);
5.46 }
5.47 }
5.48
5.49 @@ -88,8 +96,9 @@
5.50 public static
5.51 void registerBootstrapMethod(Class<?> runtime, String name) {
5.52 Class callc = Reflection.getCallerClass(2);
5.53 + Lookup lookup = new Lookup(IMPL_TOKEN, callc);
5.54 MethodHandle bootstrapMethod =
5.55 - MethodHandles.findStaticFrom(callc, runtime, name, BOOTSTRAP_METHOD_TYPE);
5.56 + lookup.findStatic(runtime, name, BOOTSTRAP_METHOD_TYPE);
5.57 // FIXME: exception processing wrong here
5.58 checkBSM(bootstrapMethod);
5.59 Linkage.registerBootstrapMethod(callc, bootstrapMethod);
5.60 @@ -106,8 +115,9 @@
5.61 public static
5.62 void registerBootstrapMethod(String name) {
5.63 Class callc = Reflection.getCallerClass(2);
5.64 + Lookup lookup = new Lookup(IMPL_TOKEN, callc);
5.65 MethodHandle bootstrapMethod =
5.66 - MethodHandles.findStaticFrom(callc, callc, name, BOOTSTRAP_METHOD_TYPE);
5.67 + lookup.findStatic(callc, name, BOOTSTRAP_METHOD_TYPE);
5.68 // FIXME: exception processing wrong here
5.69 checkBSM(bootstrapMethod);
5.70 Linkage.registerBootstrapMethod(callc, bootstrapMethod);
5.71 @@ -116,8 +126,7 @@
5.72 /**
5.73 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
5.74 * Report the bootstrap method registered for a given class.
5.75 - * Returns null if the class has never yet registered a bootstrap method,
5.76 - * or if the class has explicitly registered a null bootstrap method.
5.77 + * Returns null if the class has never yet registered a bootstrap method.
5.78 * Only callers privileged to set the bootstrap method may inquire
5.79 * about it, because a bootstrap method is potentially a back-door entry
5.80 * point into its class.
5.81 @@ -137,12 +146,12 @@
5.82 * {@code (Class, String, MethodType)} returning a {@code CallSite}.
5.83 */
5.84 public static final MethodType BOOTSTRAP_METHOD_TYPE
5.85 - = MethodType.make(CallSite.class,
5.86 - Class.class, String.class, MethodType.class);
5.87 + = MethodType.methodType(CallSite.class,
5.88 + Class.class, String.class, MethodType.class);
5.89
5.90 private static final MethodType OLD_BOOTSTRAP_METHOD_TYPE
5.91 - = MethodType.make(Object.class,
5.92 - CallSite.class, Object[].class);
5.93 + = MethodType.methodType(Object.class,
5.94 + CallSite.class, Object[].class);
5.95
5.96 private static final WeakHashMap<Class, MethodHandle> bootstrapMethods =
5.97 new WeakHashMap<Class, MethodHandle>();
5.98 @@ -173,8 +182,8 @@
5.99
5.100 /**
5.101 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
5.102 - * Invalidate all <code>invokedynamic</code> call sites associated
5.103 - * with the given class.
5.104 + * Invalidate all <code>invokedynamic</code> call sites in the bytecodes
5.105 + * of any methods of the given class.
5.106 * (These are exactly those sites which report the given class
5.107 * via the {@link CallSite#callerClass()} method.)
5.108 * <p>
6.1 --- a/src/share/classes/java/dyn/LinkagePermission.java Tue Jan 05 10:40:44 2010 +0800
6.2 +++ b/src/share/classes/java/dyn/LinkagePermission.java Wed Jan 13 15:16:06 2010 -0800
6.3 @@ -88,7 +88,7 @@
6.4 /**
6.5 * Create a new LinkagePermission with the given name.
6.6 * The name is the symbolic name of the LinkagePermission, such as
6.7 - * "registerBootstrapMethod", "invalidateClass.*", etc. An asterisk
6.8 + * "registerBootstrapMethod", "invalidateCallerClass.*", etc. An asterisk
6.9 * may appear at the end of the name, following a ".", or by itself, to
6.10 * signify a wildcard match.
6.11 *
7.1 --- a/src/share/classes/java/dyn/MethodHandle.java Tue Jan 05 10:40:44 2010 +0800
7.2 +++ b/src/share/classes/java/dyn/MethodHandle.java Wed Jan 13 15:16:06 2010 -0800
7.3 @@ -30,6 +30,9 @@
7.4 import sun.dyn.Access;
7.5 import sun.dyn.MethodHandleImpl;
7.6
7.7 +import static java.dyn.MethodHandles.invokers; // package-private API
7.8 +import static sun.dyn.MemberName.newIllegalArgumentException; // utility
7.9 +
7.10 /**
7.11 * A method handle is a typed reference to the entry point of a method.
7.12 * <p>
7.13 @@ -45,8 +48,9 @@
7.14 * Every method handle appears as an object containing a method named
7.15 * <code>invoke</code>, whose signature exactly matches
7.16 * the method handle's type.
7.17 - * A normal Java method call (using the <code>invokevirtual</code> instruction)
7.18 - * can invoke this method from Java source code (if language support is present).
7.19 + * A Java method call expression, which compiles to an
7.20 + * <code>invokevirtual</code> instruction,
7.21 + * can invoke this method from Java source code.
7.22 * <p>
7.23 * Every call to a method handle specifies an intended method type,
7.24 * which must exactly match the type of the method handle.
7.25 @@ -57,6 +61,10 @@
7.26 * The call fails with a {@link WrongMethodTypeException}
7.27 * if the method does not exist, even if there is an <code>invoke</code>
7.28 * method of a closely similar signature.
7.29 + * As with other kinds
7.30 + * of methods in the JVM, signature matching during method linkage
7.31 + * is exact, and does not allow for language-level implicit conversions
7.32 + * such as {@code String} to {@code Object} or {@code short} to {@code int}.
7.33 * <p>
7.34 * A method handle is an unrestricted capability to call a method.
7.35 * A method handle can be formed on a non-public method by a class
7.36 @@ -74,6 +82,15 @@
7.37 * (after resolving symbolic type names) must exactly match the method type
7.38 * of the target method.
7.39 * <p>
7.40 + * Every <code>invoke</code> method always throws {@link Exception},
7.41 + * which is to say that there is no static restriction on what a method handle
7.42 + * can throw. Since the JVM does not distinguish between checked
7.43 + * and unchecked exceptions (other than by their class, of course),
7.44 + * there is no particular effect on bytecode shape from ascribing
7.45 + * checked exceptions to method handle invocations. But in Java source
7.46 + * code, methods which perform method handle calls must either explicitly
7.47 + * throw {@code Exception}, or else must catch all checked exceptions locally.
7.48 + * <p>
7.49 * Bytecode in an extended JVM can directly obtain a method handle
7.50 * for any accessible method from a <code>ldc</code> instruction
7.51 * which refers to a <code>CONSTANT_Methodref</code> or
7.52 @@ -97,6 +114,59 @@
7.53 * can also be created. These do not perform virtual lookup based on
7.54 * receiver type. Such a method handle simulates the effect of
7.55 * an <code>invokespecial</code> instruction to the same method.
7.56 + * <p>
7.57 + * Here are some examples of usage:
7.58 + * <p><blockquote><pre>
7.59 + * Object x, y; String s; int i;
7.60 + * MethodType mt; MethodHandle mh;
7.61 + * MethodHandles.Lookup lookup = MethodHandles.lookup();
7.62 + * // mt is {(char,char) => String}
7.63 + * mt = MethodType.make(String.class, char.class, char.class);
7.64 + * mh = lookup.findVirtual(String.class, "replace", mt);
7.65 + * // (Ljava/lang/String;CC)Ljava/lang/String;
7.66 + * s = mh.<String>invoke("daddy",'d','n');
7.67 + * assert(s.equals("nanny"));
7.68 + * // weakly typed invocation (using MHs.invoke)
7.69 + * s = (String) MethodHandles.invoke(mh, "sappy", 'p', 'v');
7.70 + * assert(s.equals("savvy"));
7.71 + * // mt is {Object[] => List}
7.72 + * mt = MethodType.make(java.util.List.class, Object[].class);
7.73 + * mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
7.74 + * // mt is {(Object,Object,Object) => Object}
7.75 + * mt = MethodType.makeGeneric(3);
7.76 + * mh = MethodHandles.collectArguments(mh, mt);
7.77 + * // mt is {(Object,Object,Object) => Object}
7.78 + * // (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
7.79 + * x = mh.invoke((Object)1, (Object)2, (Object)3);
7.80 + * assert(x.equals(java.util.Arrays.asList(1,2,3)));
7.81 + * // mt is { => int}
7.82 + * mt = MethodType.make(int.class);
7.83 + * mh = lookup.findVirtual(java.util.List.class, "size", mt);
7.84 + * // (Ljava/util/List;)I
7.85 + * i = mh.<int>invoke(java.util.Arrays.asList(1,2,3));
7.86 + * assert(i == 3);
7.87 + * </pre></blockquote>
7.88 + * Each of the above calls generates a single invokevirtual instruction
7.89 + * with the name {@code invoke} and the type descriptors indicated in the comments.
7.90 + * The argument types are taken directly from the actual arguments,
7.91 + * while the return type is taken from the type parameter.
7.92 + * (This type parameter may be a primitive, and it defaults to {@code Object}.)
7.93 + * <p>
7.94 + * <em>A note on generic typing:</em> Method handles do not represent
7.95 + * their function types in terms of Java parameterized (generic) types,
7.96 + * because there are three mismatches between function types and parameterized
7.97 + * Java types.
7.98 + * <ol>
7.99 + * <li>Method types range over all possible arities,
7.100 + * from no arguments to an arbitrary number of arguments.
7.101 + * Generics are not variadic, and so cannot represent this.</li>
7.102 + * <li>Method types can specify arguments of primitive types,
7.103 + * which Java generic types cannot range over.</li>
7.104 + * <li>Higher order functions over method handles (combinators) are
7.105 + * often generic across a wide range of function types, including
7.106 + * those of multiple arities. It is impossible to represent such
7.107 + * genericity with a Java type parameter.</li>
7.108 + * </ol>
7.109 *
7.110 * @see MethodType
7.111 * @see MethodHandles
7.112 @@ -107,17 +177,19 @@
7.113 // with a JVM change which moves the required hidden state onto this class.
7.114 extends MethodHandleImpl
7.115 {
7.116 - // interface MethodHandle<T extends MethodType<R,A...>>
7.117 - // { T type(); <R,A...> public R invoke(A...); }
7.118 + private static Access IMPL_TOKEN = Access.getToken();
7.119
7.120 - final private MethodType type;
7.121 + // interface MethodHandle<R throws X extends Exception,A...>
7.122 + // { MethodType<R throws X,A...> type(); public R invoke(A...) throws X; }
7.123 +
7.124 + private MethodType type;
7.125
7.126 /**
7.127 * Report the type of this method handle.
7.128 * Every invocation of this method handle must exactly match this type.
7.129 * @return the method handle type
7.130 */
7.131 - public MethodType type() {
7.132 + public final MethodType type() {
7.133 return type;
7.134 }
7.135
7.136 @@ -130,6 +202,369 @@
7.137 */
7.138 protected MethodHandle(Access token, MethodType type) {
7.139 super(token);
7.140 + Access.check(token);
7.141 this.type = type;
7.142 }
7.143 +
7.144 + private void initType(MethodType type) {
7.145 + type.getClass(); // elicit NPE
7.146 + if (this.type != null) throw new InternalError();
7.147 + this.type = type;
7.148 + }
7.149 +
7.150 + static {
7.151 + // This hack allows the implementation package special access to
7.152 + // the internals of MethodHandle. In particular, the MTImpl has all sorts
7.153 + // of cached information useful to the implementation code.
7.154 + MethodHandleImpl.setMethodHandleFriend(IMPL_TOKEN, new MethodHandleImpl.MethodHandleFriend() {
7.155 + public void initType(MethodHandle mh, MethodType type) { mh.initType(type); }
7.156 + });
7.157 + }
7.158 +
7.159 + /** The string of a direct method handle is the simple name of its target method.
7.160 + * The string of an adapter or bound method handle is the string of its
7.161 + * target method handle.
7.162 + * The string of a Java method handle is the string of its entry point method,
7.163 + * unless the Java method handle overrides the toString method.
7.164 + */
7.165 + @Override
7.166 + public String toString() {
7.167 + return MethodHandleImpl.getNameString(IMPL_TOKEN, this);
7.168 + }
7.169 +
7.170 + //// First draft of the "Method Handle Kernel API" discussed at the JVM Language Summit, 9/2009.
7.171 + //// Implementations here currently delegate to statics in MethodHandles. Some of those statics
7.172 + //// will be deprecated. Others will be kept as "algorithms" to supply degrees of freedom
7.173 + //// not present in the Kernel API.
7.174 +
7.175 + /**
7.176 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.177 + * Perform an exact invocation. The signature at the call site of {@code invokeExact} must
7.178 + * exactly match this method handle's {@code type}.
7.179 + * No conversions are allowed on arguments or return values.
7.180 + * <em>This is not yet implemented, pending required compiler and JVM support.</em>
7.181 + */
7.182 + public final <T> T invokeExact(Object... arguments) throws Throwable {
7.183 + // This is an approximate implementation, which discards the caller's signature and refuses the call.
7.184 + throw new InternalError("not yet implemented");
7.185 + }
7.186 +
7.187 + /**
7.188 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.189 + * Perform a generic invocation. The signature at the call site of {@code invokeExact} must
7.190 + * have the same arity as this method handle's {@code type}.
7.191 + * The same conversions are allowed on arguments or return values as are supported by
7.192 + * by {@link MethodHandles#convertArguments}.
7.193 + * If the call site signature exactly matches this method handle's {@code type},
7.194 + * the call proceeds as if by {@link #invokeExact}.
7.195 + * <em>This is not fully implemented, pending required compiler and JVM support.</em>
7.196 + */
7.197 + // This is an approximate implementation, which discards the caller's signature.
7.198 + // When it is made signature polymorphic, the overloadings will disappear.
7.199 + public final <T> T invokeGeneric() throws Throwable {
7.200 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.201 + return invoker.<T>invoke(this);
7.202 + }
7.203 + public final <T> T invokeGeneric(Object a0) throws Throwable {
7.204 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.205 + return invoker.<T>invoke(this, a0);
7.206 + }
7.207 + public final <T> T invokeGeneric(Object a0, Object a1) throws Throwable {
7.208 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.209 + return invoker.<T>invoke(this, a0, a1);
7.210 + }
7.211 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2) throws Throwable {
7.212 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.213 + return invoker.<T>invoke(this, a0, a1, a2);
7.214 + }
7.215 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3) throws Throwable {
7.216 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.217 + return invoker.<T>invoke(this, a0, a1, a2, a3);
7.218 + }
7.219 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.220 + Object a4) throws Throwable {
7.221 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.222 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4);
7.223 + }
7.224 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.225 + Object a4, Object a5) throws Throwable {
7.226 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.227 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4, a5);
7.228 + }
7.229 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.230 + Object a4, Object a5, Object a6) throws Throwable {
7.231 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.232 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4, a5, a6);
7.233 + }
7.234 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.235 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
7.236 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.237 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4, a5, a6, a7);
7.238 + }
7.239 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.240 + Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable {
7.241 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.242 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);
7.243 + }
7.244 + public final <T> T invokeGeneric(Object a0, Object a1, Object a2, Object a3,
7.245 + Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable {
7.246 + MethodHandle invoker = invokers(this.type()).genericInvoker();
7.247 + return invoker.<T>invoke(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
7.248 + }
7.249 +
7.250 + /**
7.251 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.252 + * Perform a varargs invocation, passing the arguments in the given array
7.253 + * to the method handle, as if via {@link #invokeGeneric} from a call site
7.254 + * which mentions only the type {@code Object}, and whose arity is the length
7.255 + * of the argument array.
7.256 + * <p>
7.257 + * The length of the arguments array must equal the parameter count
7.258 + * of the target's type.
7.259 + * The arguments array is spread into separate arguments.
7.260 + * <p>
7.261 + * In order to match the type of the target, the following argument
7.262 + * conversions are applied as necessary:
7.263 + * <ul>
7.264 + * <li>reference casting
7.265 + * <li>unboxing
7.266 + * </ul>
7.267 + * The following conversions are not applied:
7.268 + * <ul>
7.269 + * <li>primitive conversions (e.g., {@code byte} to {@code int}
7.270 + * <li>varargs conversions other than the initial spread
7.271 + * <li>any application-specific conversions (e.g., string to number)
7.272 + * </ul>
7.273 + * The result returned by the call is boxed if it is a primitive,
7.274 + * or forced to null if the return type is void.
7.275 + * <p>
7.276 + * This call is equivalent to the following code:
7.277 + * <p><blockquote><pre>
7.278 + * MethodHandle invoker = MethodHandles.genericInvoker(this.type(), 0, true);
7.279 + * Object result = invoker.invoke(this, arguments);
7.280 + * </pre></blockquote>
7.281 + * @param arguments the arguments to pass to the target
7.282 + * @return the result returned by the target
7.283 + * @see MethodHandles#genericInvoker
7.284 + */
7.285 + public final Object invokeVarargs(Object[] arguments) throws Throwable {
7.286 + int argc = arguments == null ? 0 : arguments.length;
7.287 + MethodType type = type();
7.288 + if (argc <= 10) {
7.289 + MethodHandle invoker = MethodHandles.invokers(type).genericInvoker();
7.290 + switch (argc) {
7.291 + case 0: return invoker.invoke(this);
7.292 + case 1: return invoker.invoke(this,
7.293 + arguments[0]);
7.294 + case 2: return invoker.invoke(this,
7.295 + arguments[0], arguments[1]);
7.296 + case 3: return invoker.invoke(this,
7.297 + arguments[0], arguments[1], arguments[2]);
7.298 + case 4: return invoker.invoke(this,
7.299 + arguments[0], arguments[1], arguments[2],
7.300 + arguments[3]);
7.301 + case 5: return invoker.invoke(this,
7.302 + arguments[0], arguments[1], arguments[2],
7.303 + arguments[3], arguments[4]);
7.304 + case 6: return invoker.invoke(this,
7.305 + arguments[0], arguments[1], arguments[2],
7.306 + arguments[3], arguments[4], arguments[5]);
7.307 + case 7: return invoker.invoke(this,
7.308 + arguments[0], arguments[1], arguments[2],
7.309 + arguments[3], arguments[4], arguments[5],
7.310 + arguments[6]);
7.311 + case 8: return invoker.invoke(this,
7.312 + arguments[0], arguments[1], arguments[2],
7.313 + arguments[3], arguments[4], arguments[5],
7.314 + arguments[6], arguments[7]);
7.315 + case 9: return invoker.invoke(this,
7.316 + arguments[0], arguments[1], arguments[2],
7.317 + arguments[3], arguments[4], arguments[5],
7.318 + arguments[6], arguments[7], arguments[8]);
7.319 + case 10: return invoker.invoke(this,
7.320 + arguments[0], arguments[1], arguments[2],
7.321 + arguments[3], arguments[4], arguments[5],
7.322 + arguments[6], arguments[7], arguments[8],
7.323 + arguments[9]);
7.324 + }
7.325 + }
7.326 +
7.327 + // more than ten arguments get boxed in a varargs list:
7.328 + MethodHandle invoker = MethodHandles.invokers(type).varargsInvoker(0);
7.329 + return invoker.invoke(this, arguments);
7.330 + }
7.331 + /** Equivalent to {@code invokeVarargs(arguments.toArray())}. */
7.332 + public final Object invokeVarargs(java.util.List<?> arguments) throws Throwable {
7.333 + return invokeVarargs(arguments.toArray());
7.334 + }
7.335 +
7.336 + /* --- this is intentionally NOT a javadoc yet ---
7.337 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.338 + * Produce an adapter method handle which adapts the type of the
7.339 + * current method handle to a new type by pairwise argument conversion.
7.340 + * The original type and new type must have the same number of arguments.
7.341 + * The resulting method handle is guaranteed to confess a type
7.342 + * which is equal to the desired new type.
7.343 + * <p>
7.344 + * If the original type and new type are equal, returns {@code this}.
7.345 + * <p>
7.346 + * The following conversions are applied as needed both to
7.347 + * arguments and return types. Let T0 and T1 be the differing
7.348 + * new and old parameter types (or old and new return types)
7.349 + * for corresponding values passed by the new and old method types.
7.350 + * Given those types T0, T1, one of the following conversions is applied
7.351 + * if possible:
7.352 + * <ul>
7.353 + * <li>If T0 and T1 are references, and T1 is not an interface type,
7.354 + * then a cast to T1 is applied.
7.355 + * (The types do not need to be related in any particular way.)
7.356 + * <li>If T0 and T1 are references, and T1 is an interface type,
7.357 + * then the value of type T0 is passed as a T1 without a cast.
7.358 + * (This treatment of interfaces follows the usage of the bytecode verifier.)
7.359 + * <li>If T0 and T1 are primitives, then a Java casting
7.360 + * conversion (JLS 5.5) is applied, if one exists.
7.361 + * <li>If T0 and T1 are primitives and one is boolean,
7.362 + * the boolean is treated as a one-bit unsigned integer.
7.363 + * (This treatment follows the usage of the bytecode verifier.)
7.364 + * A conversion from another primitive type behaves as if
7.365 + * it first converts to byte, and then masks all but the low bit.
7.366 + * <li>If T0 is a primitive and T1 a reference, a boxing
7.367 + * conversion is applied if one exists, possibly followed by
7.368 + * an reference conversion to a superclass.
7.369 + * T1 must be a wrapper class or a supertype of one.
7.370 + * If T1 is a wrapper class, T0 is converted if necessary
7.371 + * to T1's primitive type by one of the preceding conversions.
7.372 + * Otherwise, T0 is boxed, and its wrapper converted to T1.
7.373 + * <li>If T0 is a reference and T1 a primitive, an unboxing
7.374 + * conversion is applied if one exists, possibly preceded by
7.375 + * a reference conversion to a wrapper class.
7.376 + * T0 must be a wrapper class or a supertype of one.
7.377 + * If T0 is a wrapper class, its primitive value is converted
7.378 + * if necessary to T1 by one of the preceding conversions.
7.379 + * Otherwise, T0 is converted directly to the wrapper type for T1,
7.380 + * which is then unboxed.
7.381 + * <li>If the return type T1 is void, any returned value is discarded
7.382 + * <li>If the return type T0 is void and T1 a reference, a null value is introduced.
7.383 + * <li>If the return type T0 is void and T1 a primitive, a zero value is introduced.
7.384 + * </ul>
7.385 + * <p>
7.386 + */
7.387 + /**
7.388 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.389 + * Produce an adapter method handle which adapts the type of the
7.390 + * current method handle to a new type by pairwise argument conversion.
7.391 + * The original type and new type must have the same number of arguments.
7.392 + * The resulting method handle is guaranteed to confess a type
7.393 + * which is equal to the desired new type.
7.394 + * <p>
7.395 + * If the original type and new type are equal, returns {@code this}.
7.396 + * <p>
7.397 + * This method is equivalent to {@link MethodHandles#convertArguments}.
7.398 + * @param newType the expected type of the new method handle
7.399 + * @return a method handle which delegates to {@code this} after performing
7.400 + * any necessary argument conversions, and arranges for any
7.401 + * necessary return value conversions
7.402 + * @throws IllegalArgumentException if the conversion cannot be made
7.403 + * @see MethodHandles#convertArguments
7.404 + */
7.405 + public final MethodHandle asType(MethodType newType) {
7.406 + return MethodHandles.convertArguments(this, newType);
7.407 + }
7.408 +
7.409 + /**
7.410 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.411 + * Produce a method handle which adapts, as its <i>target</i>,
7.412 + * the current method handle. The type of the adapter will be
7.413 + * the same as the type of the target, except that all but the first
7.414 + * {@code keepPosArgs} parameters of the target's type are replaced
7.415 + * by a single array parameter of type {@code Object[]}.
7.416 + * Thus, if {@code keepPosArgs} is zero, the adapter will take all
7.417 + * arguments in a single object array.
7.418 + * <p>
7.419 + * When called, the adapter replaces a trailing array argument
7.420 + * by the array's elements, each as its own argument to the target.
7.421 + * (The order of the arguments is preserved.)
7.422 + * They are converted pairwise by casting and/or unboxing
7.423 + * (as if by {@link MethodHandles#convertArguments})
7.424 + * to the types of the trailing parameters of the target.
7.425 + * Finally the target is called.
7.426 + * What the target eventually returns is returned unchanged by the adapter.
7.427 + * <p>
7.428 + * Before calling the target, the adapter verifies that the array
7.429 + * contains exactly enough elements to provide a correct argument count
7.430 + * to the target method handle.
7.431 + * (The array may also be null when zero elements are required.)
7.432 + * @param keepPosArgs the number of leading positional arguments to preserve
7.433 + * @return a new method handle which spreads its final argument,
7.434 + * before calling the original method handle
7.435 + * @throws IllegalArgumentException if target does not have at least
7.436 + * {@code keepPosArgs} parameter types
7.437 + */
7.438 + public final MethodHandle asSpreader(int keepPosArgs) {
7.439 + MethodType oldType = type();
7.440 + int nargs = oldType.parameterCount();
7.441 + MethodType newType = oldType.dropParameterTypes(keepPosArgs, nargs);
7.442 + newType = newType.insertParameterTypes(keepPosArgs, Object[].class);
7.443 + return MethodHandles.spreadArguments(this, newType);
7.444 + }
7.445 +
7.446 + /**
7.447 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.448 + * Produce a method handle which adapts, as its <i>target</i>,
7.449 + * the current method handle. The type of the adapter will be
7.450 + * the same as the type of the target, except that a single trailing
7.451 + * array parameter of type {@code Object[]} is replaced by
7.452 + * {@code spreadArrayArgs} parameters of type {@code Object}.
7.453 + * <p>
7.454 + * When called, the adapter replaces its trailing {@code spreadArrayArgs}
7.455 + * arguments by a single new {@code Object} array, whose elements
7.456 + * comprise (in order) the replaced arguments.
7.457 + * Finally the target is called.
7.458 + * What the target eventually returns is returned unchanged by the adapter.
7.459 + * <p>
7.460 + * (The array may also be a shared constant when {@code spreadArrayArgs} is zero.)
7.461 + * @param spreadArrayArgs the number of arguments to spread from the trailing array
7.462 + * @return a new method handle which collects some trailing argument
7.463 + * into an array, before calling the original method handle
7.464 + * @throws IllegalArgumentException if the last argument of the target
7.465 + * is not {@code Object[]}
7.466 + * @throws IllegalArgumentException if {@code spreadArrayArgs} is not
7.467 + * a legal array size
7.468 + * @deprecated Provisional and unstable; use {@link MethodHandles#collectArguments}.
7.469 + */
7.470 + public final MethodHandle asCollector(int spreadArrayArgs) {
7.471 + MethodType oldType = type();
7.472 + int nargs = oldType.parameterCount();
7.473 + MethodType newType = oldType.dropParameterTypes(nargs-1, nargs);
7.474 + newType = newType.insertParameterTypes(nargs-1, MethodType.genericMethodType(spreadArrayArgs).parameterArray());
7.475 + return MethodHandles.collectArguments(this, newType);
7.476 + }
7.477 +
7.478 + /**
7.479 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
7.480 + * Produce a method handle which binds the given argument
7.481 + * to the current method handle as <i>target</i>.
7.482 + * The type of the bound handle will be
7.483 + * the same as the type of the target, except that a single leading
7.484 + * reference parameter will be omitted.
7.485 + * <p>
7.486 + * When called, the bound handle inserts the given value {@code x}
7.487 + * as a new leading argument to the target. The other arguments are
7.488 + * also passed unchanged.
7.489 + * What the target eventually returns is returned unchanged by the bound handle.
7.490 + * <p>
7.491 + * The reference {@code x} must be convertible to the first parameter
7.492 + * type of the target.
7.493 + * @param x the value to bind to the first argument of the target
7.494 + * @return a new method handle which collects some trailing argument
7.495 + * into an array, before calling the original method handle
7.496 + * @throws IllegalArgumentException if the target does not have a
7.497 + * leading parameter type that is a reference type
7.498 + * @throws ClassCastException if {@code x} cannot be converted
7.499 + * to the leading parameter type of the target
7.500 + * @deprecated Provisional and unstable; use {@link MethodHandles#insertArguments}.
7.501 + */
7.502 + public final MethodHandle bindTo(Object x) {
7.503 + return MethodHandles.insertArguments(this, 0, x);
7.504 + }
7.505 }
8.1 --- a/src/share/classes/java/dyn/MethodHandles.java Tue Jan 05 10:40:44 2010 +0800
8.2 +++ b/src/share/classes/java/dyn/MethodHandles.java Wed Jan 13 15:16:06 2010 -0800
8.3 @@ -34,6 +34,7 @@
8.4 import java.lang.reflect.Field;
8.5 import java.lang.reflect.Method;
8.6 import java.lang.reflect.Modifier;
8.7 +import java.util.List;
8.8 import java.util.ArrayList;
8.9 import java.util.Arrays;
8.10 import sun.dyn.Invokers;
8.11 @@ -44,17 +45,14 @@
8.12
8.13 /**
8.14 * Fundamental operations and utilities for MethodHandle.
8.15 + * They fall into several categories:
8.16 + * <ul>
8.17 + * <li>Reifying methods and fields. This is subject to access checks.
8.18 + * <li>Invoking method handles on dynamically typed arguments and/or varargs arrays.
8.19 + * <li>Combining or transforming pre-existing method handles into new ones.
8.20 + * <li>Miscellaneous emulation of common JVM operations or control flow patterns.
8.21 + * </ul>
8.22 * <p>
8.23 - * <em>API Note:</em> The matching of method types in this API cannot
8.24 - * be completely checked by Java's generic type system for three reasons:
8.25 - * <ol>
8.26 - * <li>Method types range over all possible arities,
8.27 - * from no arguments to an arbitrary number of arguments.
8.28 - * Generics are not variadic, and so cannot represent this.</li>
8.29 - * <li>Method types can specify arguments of primitive types,
8.30 - * which Java generic types cannot range over.</li>
8.31 - * <li>Method types can optionally specify varargs (ellipsis).</li>
8.32 - * </ol>
8.33 * @author John Rose, JSR 292 EG
8.34 */
8.35 public class MethodHandles {
8.36 @@ -68,12 +66,22 @@
8.37
8.38 //// Method handle creation from ordinary methods.
8.39
8.40 + /** Create a {@link Lookup} lookup object on the caller.
8.41 + *
8.42 + */
8.43 public static Lookup lookup() {
8.44 return new Lookup();
8.45 }
8.46
8.47 + /** Version of lookup which is trusted minimally.
8.48 + * It can only be used to create method handles to
8.49 + * publicly accessible members.
8.50 + */
8.51 + public static Lookup publicLookup() {
8.52 + return Lookup.PUBLIC_LOOKUP;
8.53 + }
8.54 +
8.55 /**
8.56 - * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.57 * A factory object for creating method handles, when the creation
8.58 * requires access checking. Method handles do not perform
8.59 * access checks when they are called; this is a major difference
8.60 @@ -121,7 +129,8 @@
8.61 /** Which class is performing the lookup? It is this class against
8.62 * which checks are performed for visibility and access permissions.
8.63 * <p>
8.64 - * This value is null if and only if this lookup is {@link #PUBLIC_LOOKUP}.
8.65 + * This value is null if and only if this lookup was produced
8.66 + * by {@link MethodHandles#publicLookup}.
8.67 */
8.68 public Class<?> lookupClass() {
8.69 return lookupClass;
8.70 @@ -135,23 +144,46 @@
8.71 * an access$N method.
8.72 */
8.73 Lookup() {
8.74 - Class caller = getCallerClassAtEntryPoint();
8.75 - // make sure we haven't accidentally picked up this class:
8.76 - checkUnprivilegedlookupClass(caller);
8.77 - this.lookupClass = caller;
8.78 + this(IMPL_TOKEN, getCallerClassAtEntryPoint());
8.79 + }
8.80 +
8.81 + Lookup(Access token, Class<?> lookupClass) {
8.82 + // make sure we haven't accidentally picked up a privileged class:
8.83 + checkUnprivilegedlookupClass(lookupClass);
8.84 + this.lookupClass = lookupClass;
8.85 + }
8.86 +
8.87 + /**
8.88 + * Create a lookup on the specified class.
8.89 + * The result is guaranteed to have no more access privileges
8.90 + * than the original.
8.91 + */
8.92 + public Lookup in(Class<?> newLookupClass) {
8.93 + if (this == PUBLIC_LOOKUP) return PUBLIC_LOOKUP;
8.94 + if (newLookupClass == null) return PUBLIC_LOOKUP;
8.95 + if (newLookupClass == lookupClass) return this;
8.96 + if (this != IMPL_LOOKUP) {
8.97 + if (!VerifyAccess.isSamePackage(lookupClass, newLookupClass))
8.98 + throw newNoAccessException(new MemberName(newLookupClass), this);
8.99 + checkUnprivilegedlookupClass(newLookupClass);
8.100 + }
8.101 + return new Lookup(newLookupClass);
8.102 }
8.103
8.104 private Lookup(Class<?> lookupClass) {
8.105 this.lookupClass = lookupClass;
8.106 }
8.107
8.108 + // Make sure outer class is initialized first.
8.109 + static { IMPL_TOKEN.getClass(); }
8.110 +
8.111 private static final Class<?> PUBLIC_ONLY = sun.dyn.empty.Empty.class;
8.112
8.113 /** Version of lookup which is trusted minimally.
8.114 * It can only be used to create method handles to
8.115 * publicly accessible members.
8.116 */
8.117 - public static final Lookup PUBLIC_LOOKUP = new Lookup(PUBLIC_ONLY);
8.118 + static final Lookup PUBLIC_LOOKUP = new Lookup(PUBLIC_ONLY);
8.119
8.120 /** Package-private version of lookup which is trusted. */
8.121 static final Lookup IMPL_LOOKUP = new Lookup(null);
8.122 @@ -178,12 +210,16 @@
8.123 // 0: Reflection.getCC, 1: getCallerClassAtEntryPoint,
8.124 // 2: Lookup.<init>, 3: MethodHandles.*, 4: caller
8.125 // Note: This should be the only use of getCallerClass in this file.
8.126 + assert(Reflection.getCallerClass(CALLER_DEPTH-1) == MethodHandles.class);
8.127 return Reflection.getCallerClass(CALLER_DEPTH);
8.128 }
8.129
8.130 /**
8.131 * Produce a method handle for a static method.
8.132 * The type of the method handle will be that of the method.
8.133 + * (Since static methods do not take receivers, there is no
8.134 + * additional receiver argument inserted into the method handle type,
8.135 + * as there would be with {@linkplain #findVirtual} or {@linkplain #findSpecial}.)
8.136 * The method and all its argument types must be accessible to the lookup class.
8.137 * If the method's class has not yet been initialized, that is done
8.138 * immediately, before the method handle is returned.
8.139 @@ -196,10 +232,11 @@
8.140 */
8.141 public
8.142 MethodHandle findStatic(Class<?> defc, String name, MethodType type) throws NoAccessException {
8.143 - MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookupClass);
8.144 - checkStatic(true, method, lookupClass);
8.145 + MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookupClass());
8.146 + VerifyAccess.checkName(method, this);
8.147 + checkStatic(true, method, this);
8.148 //throw NoSuchMethodException
8.149 - return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClass);
8.150 + return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClass());
8.151 }
8.152
8.153 /**
8.154 @@ -228,9 +265,10 @@
8.155 * @exception NoAccessException if the method does not exist or access checking fails
8.156 */
8.157 public MethodHandle findVirtual(Class<?> defc, String name, MethodType type) throws NoAccessException {
8.158 - MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), true, lookupClass);
8.159 - checkStatic(false, method, lookupClass);
8.160 - return MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass);
8.161 + MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), true, lookupClass());
8.162 + VerifyAccess.checkName(method, this);
8.163 + checkStatic(false, method, this);
8.164 + return MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass());
8.165 }
8.166
8.167 /**
8.168 @@ -259,15 +297,17 @@
8.169 */
8.170 public MethodHandle findSpecial(Class<?> defc, String name, MethodType type,
8.171 Class<?> specialCaller) throws NoAccessException {
8.172 - checkSpecialCaller(specialCaller, lookupClass);
8.173 - MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), false, specialCaller);
8.174 - checkStatic(false, method, lookupClass);
8.175 + checkSpecialCaller(specialCaller, this);
8.176 + Lookup slookup = this.in(specialCaller);
8.177 + MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type), false, slookup.lookupClass());
8.178 + VerifyAccess.checkName(method, this);
8.179 + checkStatic(false, method, this);
8.180 if (name.equals("<init>")) {
8.181 throw newNoAccessException("cannot directly invoke a constructor", method, null);
8.182 } else if (defc.isInterface() || !defc.isAssignableFrom(specialCaller)) {
8.183 - throw newNoAccessException("method must be in a superclass of lookup class", method, lookupClass);
8.184 + throw newNoAccessException("method must be in a superclass of lookup class", method, slookup.lookupClass());
8.185 }
8.186 - return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, specialCaller);
8.187 + return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, slookup.lookupClass());
8.188 }
8.189
8.190 /**
8.191 @@ -275,13 +315,19 @@
8.192 * The receiver must have a supertype {@code defc} in which a method
8.193 * of the given name and type is accessible to the lookup class.
8.194 * The method and all its argument types must be accessible to the lookup class.
8.195 - * The type of the method handle will be that of the method.
8.196 - * The given receiver will be bound into the method handle.
8.197 + * The type of the method handle will be that of the method,
8.198 + * without any insertion of an additional receiver parameter.
8.199 + * The given receiver will be bound into the method handle,
8.200 + * so that every call to the method handle will invoke the
8.201 + * requested method on the given receiver.
8.202 * <p>
8.203 - * Equivalent to the following expression:
8.204 + * This is equivalent to the following expression:
8.205 * <code>
8.206 - * {@link #insertArgument}({@link #findVirtual}(defc, name, type), receiver)
8.207 + * {@link #insertArguments}({@link #findVirtual}(defc, name, type), receiver)
8.208 * </code>
8.209 + * where {@code defc} is either {@code receiver.getClass()} or a super
8.210 + * type of that class, in which the requested method is accessible
8.211 + * to the lookup class.
8.212 * @param receiver the object from which the method is accessed
8.213 * @param name the name of the method
8.214 * @param type the type of the method, with the receiver argument omitted
8.215 @@ -292,16 +338,18 @@
8.216 public MethodHandle bind(Object receiver, String name, MethodType type) throws NoAccessException {
8.217 Class<? extends Object> rcvc = receiver.getClass(); // may get NPE
8.218 MemberName reference = new MemberName(rcvc, name, type);
8.219 - MemberName method = IMPL_NAMES.resolveOrFail(reference, true, lookupClass);
8.220 - checkStatic(false, method, lookupClass);
8.221 - MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass);
8.222 + MemberName method = IMPL_NAMES.resolveOrFail(reference, true, lookupClass());
8.223 + VerifyAccess.checkName(method, this);
8.224 + checkStatic(false, method, this);
8.225 + MethodHandle dmh = MethodHandleImpl.findMethod(IMPL_TOKEN, method, true, lookupClass());
8.226 MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, dmh, receiver);
8.227 if (bmh == null)
8.228 - throw newNoAccessException(method, lookupClass);
8.229 + throw newNoAccessException(method, this);
8.230 return bmh;
8.231 }
8.232
8.233 /**
8.234 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.235 * Make a direct method handle to <i>m</i>, if the lookup class has permission.
8.236 * If <i>m</i> is non-static, the receiver argument is treated as an initial argument.
8.237 * If <i>m</i> is virtual, overriding is respected on every call.
8.238 @@ -316,10 +364,11 @@
8.239 * @exception NoAccessException if access checking fails
8.240 */
8.241 public MethodHandle unreflect(Method m) throws NoAccessException {
8.242 - return unreflectImpl(new MemberName(m), m.isAccessible(), true, lookupClass);
8.243 + return unreflectImpl(new MemberName(m), m.isAccessible(), true, false, this);
8.244 }
8.245
8.246 /**
8.247 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.248 * Produce a method handle for a reflected method.
8.249 * It will bypass checks for overriding methods on the receiver,
8.250 * as if by the {@code invokespecial} instruction.
8.251 @@ -333,37 +382,41 @@
8.252 * @exception NoAccessException if access checking fails
8.253 */
8.254 public MethodHandle unreflectSpecial(Method m, Class<?> specialCaller) throws NoAccessException {
8.255 - checkSpecialCaller(specialCaller, lookupClass);
8.256 + checkSpecialCaller(specialCaller, this);
8.257 + Lookup slookup = this.in(specialCaller);
8.258 MemberName mname = new MemberName(m);
8.259 - checkStatic(false, mname, lookupClass);
8.260 - return unreflectImpl(mname, m.isAccessible(), false, specialCaller);
8.261 + checkStatic(false, mname, this);
8.262 + return unreflectImpl(mname, m.isAccessible(), false, false, slookup);
8.263 }
8.264
8.265 /**
8.266 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.267 * Produce a method handle for a reflected constructor.
8.268 - * The type of the method handle will be that of the constructor.
8.269 + * The type of the method handle will be that of the constructor,
8.270 + * with the return type changed to the declaring class.
8.271 * The method handle will perform a {@code newInstance} operation,
8.272 * creating a new instance of the constructor's class on the
8.273 * arguments passed to the method handle.
8.274 * <p>
8.275 * If the constructor's {@code accessible} flag is not set,
8.276 - * access checking is performed immediately on behalf of the lookup class,
8.277 - * as if {@code invokespecial} instruction were being linked.
8.278 + * access checking is performed immediately on behalf of the lookup class.
8.279 * @param ctor the reflected constructor
8.280 * @return a method handle which can invoke the reflected constructor
8.281 * @exception NoAccessException if access checking fails
8.282 */
8.283 public MethodHandle unreflectConstructor(Constructor ctor) throws NoAccessException {
8.284 MemberName m = new MemberName(ctor);
8.285 - return unreflectImpl(m, ctor.isAccessible(), false, lookupClass);
8.286 + return unreflectImpl(m, ctor.isAccessible(), false, false, this);
8.287 }
8.288
8.289 /**
8.290 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.291 * Produce a method handle giving read access to a reflected field.
8.292 * The type of the method handle will have a return type of the field's
8.293 - * value type. Its sole argument will be the field's containing class
8.294 - * (but only if it is non-static).
8.295 + * value type.
8.296 + * If the field is static, the method handle will take no arguments.
8.297 + * Otherwise, its single argument will be the instance containing
8.298 + * the field.
8.299 * If the method's {@code accessible} flag is not set,
8.300 * access checking is performed immediately on behalf of the lookup class.
8.301 * @param f the reflected field
8.302 @@ -371,16 +424,18 @@
8.303 * @exception NoAccessException if access checking fails
8.304 */
8.305 public MethodHandle unreflectGetter(Field f) throws NoAccessException {
8.306 - return MethodHandleImpl.accessField(IMPL_TOKEN, new MemberName(f), false, lookupClass);
8.307 + MemberName m = new MemberName(f);
8.308 + return unreflectImpl(m, f.isAccessible(), false, false, this);
8.309 }
8.310
8.311 /**
8.312 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.313 * Produce a method handle giving write access to a reflected field.
8.314 * The type of the method handle will have a void return type.
8.315 - * Its last argument will be the field's value type.
8.316 - * Its other argument will be the field's containing class
8.317 - * (but only if it is non-static).
8.318 + * If the field is static, the method handle will take a single
8.319 + * argument, of the field's value type, the value to be stored.
8.320 + * Otherwise, the two arguments will be the instance containing
8.321 + * the field, and the value to be stored.
8.322 * If the method's {@code accessible} flag is not set,
8.323 * access checking is performed immediately on behalf of the lookup class.
8.324 * @param f the reflected field
8.325 @@ -388,59 +443,75 @@
8.326 * @exception NoAccessException if access checking fails
8.327 */
8.328 public MethodHandle unreflectSetter(Field f) throws NoAccessException {
8.329 - return MethodHandleImpl.accessField(IMPL_TOKEN, new MemberName(f), true, lookupClass);
8.330 + MemberName m = new MemberName(f);
8.331 + return unreflectImpl(m, f.isAccessible(), false, true, this);
8.332 }
8.333
8.334 }
8.335
8.336 static /*must not be public*/
8.337 - MethodHandle findStaticFrom(Class<?> lookupClass,
8.338 + MethodHandle findStaticFrom(Lookup lookup,
8.339 Class<?> defc, String name, MethodType type) throws NoAccessException {
8.340 - MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookupClass);
8.341 - checkStatic(true, method, lookupClass);
8.342 - return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookupClass);
8.343 + MemberName method = IMPL_NAMES.resolveOrFail(new MemberName(defc, name, type, Modifier.STATIC), true, lookup.lookupClass());
8.344 + VerifyAccess.checkName(method, lookup);
8.345 + checkStatic(true, method, lookup);
8.346 + return MethodHandleImpl.findMethod(IMPL_TOKEN, method, false, lookup.lookupClass());
8.347 }
8.348
8.349 - static void checkStatic(boolean wantStatic, MemberName m, Class<?> lookupClass) {
8.350 + static void checkStatic(boolean wantStatic, MemberName m, Lookup lookup) {
8.351 if (wantStatic != m.isStatic()) {
8.352 String message = wantStatic ? "expected a static method" : "expected a non-static method";
8.353 - throw newNoAccessException(message, m, lookupClass);
8.354 + throw newNoAccessException(message, m, lookup.lookupClass());
8.355 }
8.356 }
8.357
8.358 - static void checkSpecialCaller(Class<?> specialCaller, Class<?> lookupClass) {
8.359 - if (lookupClass == Lookup.IMPL_LOOKUP.lookupClass())
8.360 + static void checkSpecialCaller(Class<?> specialCaller, Lookup lookup) {
8.361 + if (lookup == Lookup.IMPL_LOOKUP)
8.362 return; // privileged action
8.363 - if (lookupClass == null || // public-only access
8.364 - !VerifyAccess.isSamePackageMember(specialCaller, lookupClass))
8.365 - throw newNoAccessException("no private access", new MemberName(specialCaller), lookupClass);
8.366 + assert(lookup.lookupClass() != null);
8.367 + if (!VerifyAccess.isSamePackageMember(specialCaller, lookup.lookupClass()))
8.368 + throw newNoAccessException("no private access", new MemberName(specialCaller), lookup.lookupClass());
8.369 }
8.370
8.371 // Helper for creating handles on reflected methods and constructors.
8.372 static MethodHandle unreflectImpl(MemberName m, boolean isAccessible,
8.373 - boolean doDispatch, Class<?> lookupClass) {
8.374 - MethodType mtype = m.getInvocationType();
8.375 + boolean doDispatch, boolean isSetter, Lookup lookup) {
8.376 + MethodType narrowMethodType = null;
8.377 Class<?> defc = m.getDeclaringClass();
8.378 + boolean isSpecialInvoke = m.isInvocable() && !doDispatch;
8.379 int mods = m.getModifiers();
8.380 if (m.isStatic()) {
8.381 if (!isAccessible &&
8.382 - VerifyAccess.isAccessible(defc, mods, false, lookupClass) == null)
8.383 - throw newNoAccessException(m, lookupClass);
8.384 + VerifyAccess.isAccessible(defc, mods, lookup.lookupClass(), false) == null)
8.385 + throw newNoAccessException(m, lookup);
8.386 } else {
8.387 Class<?> constraint;
8.388 if (isAccessible) {
8.389 // abbreviated access check for "unlocked" method
8.390 - constraint = doDispatch ? defc : lookupClass;
8.391 + constraint = doDispatch ? defc : lookup.lookupClass();
8.392 } else {
8.393 - constraint = VerifyAccess.isAccessible(defc, mods, doDispatch, lookupClass);
8.394 + constraint = VerifyAccess.isAccessible(defc, mods, lookup.lookupClass(), isSpecialInvoke);
8.395 + }
8.396 + if (constraint == null) {
8.397 + throw newNoAccessException(m, lookup);
8.398 }
8.399 if (constraint != defc && !constraint.isAssignableFrom(defc)) {
8.400 if (!defc.isAssignableFrom(constraint))
8.401 - throw newNoAccessException("receiver must be in caller class", m, lookupClass);
8.402 - mtype = mtype.changeParameterType(0, constraint);
8.403 + throw newNoAccessException("receiver must be in caller class", m, lookup.lookupClass());
8.404 + if (m.isInvocable())
8.405 + narrowMethodType = m.getInvocationType().changeParameterType(0, constraint);
8.406 + else if (m.isField())
8.407 + narrowMethodType = (!isSetter
8.408 + ? MethodType.methodType(m.getFieldType(), constraint)
8.409 + : MethodType.methodType(void.class, constraint, m.getFieldType()));
8.410 }
8.411 }
8.412 - return MethodHandleImpl.findMethod(IMPL_TOKEN, m, doDispatch, lookupClass);
8.413 + if (m.isInvocable())
8.414 + return MethodHandleImpl.findMethod(IMPL_TOKEN, m, doDispatch, lookup.lookupClass());
8.415 + else if (m.isField())
8.416 + return MethodHandleImpl.accessField(IMPL_TOKEN, m, isSetter, lookup.lookupClass());
8.417 + else
8.418 + throw new InternalError();
8.419 }
8.420
8.421 /**
8.422 @@ -472,138 +543,104 @@
8.423 return MethodHandleImpl.accessArrayElement(IMPL_TOKEN, arrayClass, true);
8.424 }
8.425
8.426 -
8.427 /// method handle invocation (reflective style)
8.428
8.429 /**
8.430 - * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.431 - * Call the {@code invoke} method of a given method handle,
8.432 - * with arguments that exactly match the parameter types of the method handle.
8.433 - * The length of the arguments array must equal the parameter count
8.434 - * of the target's type.
8.435 - * The arguments array is spread into separate arguments, and
8.436 - * basic reference and unboxing conversions are applied.
8.437 - * <p>
8.438 - * In order to match the type of the target, the following argument
8.439 - * conversions are applied as necessary:
8.440 - * <ul>
8.441 - * <li>reference casting
8.442 - * <li>unboxing
8.443 - * </ul>
8.444 - * The following conversions are not applied:
8.445 - * <ul>
8.446 - * <li>primitive conversions (e.g., {@code byte} to {@code int}
8.447 - * <li>varargs conversions other than the initial spread
8.448 - * <li>any application-specific conversions (e.g., string to number)
8.449 - * </ul>
8.450 - * The result returned by the call is boxed if it is a primitive,
8.451 - * or forced to null if the return type is void.
8.452 - * <p>
8.453 - * This call is a convenience method for the following code:
8.454 - * <pre>
8.455 - * MethodHandle invoker = MethodHandles.genericInvoker(target.type(), 0, true);
8.456 - * Object result = invoker.invoke(arguments);
8.457 - * </pre>
8.458 - * @param target the method handle to invoke
8.459 - * @param arguments the arguments to pass to the target
8.460 - * @return the result returned by the target
8.461 + * @deprecated Alias for MethodHandle.invokeVarargs.
8.462 */
8.463 + @Deprecated
8.464 public static
8.465 - Object invoke(MethodHandle target, Object... arguments) {
8.466 - int argc = arguments == null ? 0 : arguments.length;
8.467 - MethodType type = target.type();
8.468 - if (argc <= 4) {
8.469 - MethodHandle invoker = invokers(type).genericInvoker();
8.470 - switch (argc) {
8.471 - case 0: return invoker.<Object>invoke(target);
8.472 - case 1: return invoker.<Object>invoke(target,
8.473 - arguments[0]);
8.474 - case 2: return invoker.<Object>invoke(target,
8.475 - arguments[0], arguments[1]);
8.476 - case 3: return invoker.<Object>invoke(target,
8.477 - arguments[0], arguments[1], arguments[2]);
8.478 - case 4: return invoker.<Object>invoke(target,
8.479 - arguments[0], arguments[1], arguments[2], arguments[3]);
8.480 - }
8.481 - }
8.482 - MethodHandle invoker = invokers(type).varargsInvoker();
8.483 - return invoker.<Object>invoke(target, arguments);
8.484 + Object invokeVarargs(MethodHandle target, Object... arguments) throws Throwable {
8.485 + return target.invokeVarargs(arguments);
8.486 }
8.487
8.488 + /**
8.489 + * @deprecated Alias for MethodHandle.invokeVarargs.
8.490 + */
8.491 + @Deprecated
8.492 public static
8.493 - Object invoke_0(MethodHandle target) {
8.494 - MethodHandle invoker = invokers(target.type()).genericInvoker();
8.495 - return invoker.<Object>invoke(target);
8.496 - }
8.497 - public static
8.498 - Object invoke_1(MethodHandle target, Object a0) {
8.499 - MethodHandle invoker = invokers(target.type()).genericInvoker();
8.500 - return invoker.<Object>invoke(target, a0);
8.501 - }
8.502 - public static
8.503 - Object invoke_2(MethodHandle target, Object a0, Object a1) {
8.504 - MethodHandle invoker = invokers(target.type()).genericInvoker();
8.505 - return invoker.<Object>invoke(target, a0, a1);
8.506 - }
8.507 - public static
8.508 - Object invoke_3(MethodHandle target, Object a0, Object a1, Object a2) {
8.509 - MethodHandle invoker = invokers(target.type()).genericInvoker();
8.510 - return invoker.<Object>invoke(target, a0, a1, a2);
8.511 - }
8.512 - public static
8.513 - Object invoke_4(MethodHandle target, Object a0, Object a1, Object a2, Object a3) {
8.514 - MethodHandle invoker = invokers(target.type()).genericInvoker();
8.515 - return invoker.<Object>invoke(target, a0, a1, a2, a3);
8.516 + Object invoke(MethodHandle target, Object... arguments) throws Throwable {
8.517 + return target.invokeVarargs(arguments);
8.518 }
8.519
8.520 /**
8.521 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.522 - * Give a method handle which will invoke any method handle of the
8.523 + * Produce a method handle which will invoke any method handle of the
8.524 * given type on a standard set of {@code Object} type arguments.
8.525 - * The the resulting invoker will be a method handle with the following
8.526 + * The resulting invoker will be a method handle with the following
8.527 * arguments:
8.528 * <ul>
8.529 * <li>a single {@code MethodHandle} target
8.530 - * <li>zero or more {@code Object} values
8.531 - * <li>an optional {@code Object[]} array containing more arguments
8.532 + * <li>zero or more {@code Object} values (one for each argument in {@code type})
8.533 * </ul>
8.534 - * The invoker will spread the varargs array (if present), apply
8.535 + * The invoker will apply reference casts as necessary and unbox primitive arguments,
8.536 + * as if by {@link #convertArguments}.
8.537 + * The return value of the invoker will be an {@code Object} reference,
8.538 + * boxing a primitive value if the original type returns a primitive,
8.539 + * and always null if the original type returns void.
8.540 + * <p>
8.541 + * This method is equivalent to the following code (though it may be more efficient):
8.542 + * <p><blockquote><pre>
8.543 + * MethodHandle invoker = exactInvoker(type);
8.544 + * MethodType genericType = type.generic();
8.545 + * genericType = genericType.insertParameterType(0, MethodHandle.class);
8.546 + * return convertArguments(invoker, genericType);
8.547 + * </pre></blockquote>
8.548 + * @param type the type of target methods which the invoker will apply to
8.549 + * @return a method handle suitable for invoking any method handle of the given type
8.550 + */
8.551 + static public
8.552 + MethodHandle genericInvoker(MethodType type) {
8.553 + return invokers(type).genericInvoker();
8.554 + }
8.555 +
8.556 + /**
8.557 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.558 + * Produce a method handle which will invoke any method handle of the
8.559 + * given type on a standard set of {@code Object} type arguments
8.560 + * and a single trailing {@code Object[]} array.
8.561 + * The resulting invoker will be a method handle with the following
8.562 + * arguments:
8.563 + * <ul>
8.564 + * <li>a single {@code MethodHandle} target
8.565 + * <li>zero or more {@code Object} values (counted by {@code objectArgCount})
8.566 + * <li>an {@code Object[]} array containing more arguments
8.567 + * </ul>
8.568 + * The invoker will spread the varargs array, apply
8.569 * reference casts as necessary, and unbox primitive arguments.
8.570 * The return value of the invoker will be an {@code Object} reference,
8.571 * boxing a primitive value if the original type returns a primitive,
8.572 * and always null if the original type returns void.
8.573 * <p>
8.574 - * This is a convenience method equivalent to the following code:
8.575 - * <pre>
8.576 + * This method is equivalent to the following code (though it may be more efficient):
8.577 + * <p><blockquote><pre>
8.578 * MethodHandle invoker = exactInvoker(type);
8.579 - * MethodType genericType = MethodType.makeGeneric(objectArgCount, varargs);
8.580 - * genericType = genericType.insertParameterType(0, MethodHandle.class);
8.581 - * if (!varargs)
8.582 - * return convertArguments(invoker, genericType);
8.583 - * else
8.584 - * return spreadArguments(invoker, genericType);
8.585 - * </pre>
8.586 + * MethodType vaType = MethodType.makeGeneric(objectArgCount, true);
8.587 + * vaType = vaType.insertParameterType(0, MethodHandle.class);
8.588 + * return spreadArguments(invoker, vaType);
8.589 + * </pre></blockquote>
8.590 * @param type the desired target type
8.591 * @param objectArgCount number of fixed (non-varargs) {@code Object} arguments
8.592 - * @param varargs if true, the invoker will accept a final {@code Object[]} argument
8.593 * @return a method handle suitable for invoking any method handle of the given type
8.594 */
8.595 static public
8.596 - MethodHandle genericInvoker(MethodType type, int objectArgCount, boolean varargs) {
8.597 - return invokers(type).genericInvoker();
8.598 + MethodHandle varargsInvoker(MethodType type, int objectArgCount) {
8.599 + if (objectArgCount < 0 || objectArgCount > type.parameterCount())
8.600 + throw new IllegalArgumentException("bad argument count "+objectArgCount);
8.601 + return invokers(type).varargsInvoker(objectArgCount);
8.602 }
8.603
8.604 /**
8.605 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.606 - * Give a method handle which will take a invoke any method handle of the
8.607 + * Produce a method handle which will take a invoke any method handle of the
8.608 * given type. The resulting invoker will have a type which is
8.609 * exactly equal to the desired type, except that it will accept
8.610 * an additional leading argument of type {@code MethodHandle}.
8.611 * <p>
8.612 - * This is a convenience method equivalent to the following code:
8.613 - * <pre>
8.614 - * MethodHandles.lookup().findVirtual(MethodHandle.class, "invoke", type);
8.615 - * </pre>
8.616 + * This method is equivalent to the following code (though it may be more efficient):
8.617 + * <p><blockquote><pre>
8.618 + * lookup().findVirtual(MethodHandle.class, "invoke", type);
8.619 + * </pre></blockquote>
8.620 * @param type the desired target type
8.621 * @return a method handle suitable for invoking any method handle of the given type
8.622 */
8.623 @@ -612,7 +649,30 @@
8.624 return invokers(type).exactInvoker();
8.625 }
8.626
8.627 - static private Invokers invokers(MethodType type) {
8.628 + /**
8.629 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.630 + * Produce a method handle equivalent to an invokedynamic instruction
8.631 + * which has been linked to the given call site.
8.632 + * Along with {@link Lookup#findVirtual}, {@link Lookup#findStatic},
8.633 + * and {@link Lookup#findSpecial}, this completes the emulation
8.634 + * of the JVM's {@code invoke} instructions.
8.635 + * <p>This method is equivalent to the following code:
8.636 + * <p><blockquote><pre>
8.637 + * MethodHandle getTarget, invoker, result;
8.638 + * getTarget = lookup().bind(site, "getTarget", methodType(MethodHandle.class));
8.639 + * invoker = exactInvoker(site.type());
8.640 + * result = foldArguments(invoker, getTarget)
8.641 + * </pre></blockquote>
8.642 + * @return a method handle which always invokes the call site's target
8.643 + */
8.644 + public static
8.645 + MethodHandle dynamicInvoker(CallSite site) {
8.646 + MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, CallSite.GET_TARGET, site);
8.647 + MethodHandle invoker = exactInvoker(site.type());
8.648 + return foldArguments(invoker, getTarget);
8.649 + }
8.650 +
8.651 + static Invokers invokers(MethodType type) {
8.652 return MethodTypeImpl.invokers(IMPL_TOKEN, type);
8.653 }
8.654
8.655 @@ -688,14 +748,11 @@
8.656 /// method handle modification (creation from other method handles)
8.657
8.658 /**
8.659 - * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.660 * Produce a method handle which adapts the type of the
8.661 - * given method handle to a new type, by pairwise argument conversion,
8.662 - * and/or varargs conversion.
8.663 - * The original type and new type must have the same number of
8.664 - * arguments, or else one or both them the must be varargs types.
8.665 + * given method handle to a new type by pairwise argument conversion.
8.666 + * The original type and new type must have the same number of arguments.
8.667 * The resulting method handle is guaranteed to confess a type
8.668 - * which is equal to the desired new type, with any varargs property erased.
8.669 + * which is equal to the desired new type.
8.670 * <p>
8.671 * If the original type and new type are equal, returns target.
8.672 * <p>
8.673 @@ -703,26 +760,15 @@
8.674 * arguments and return types. Let T0 and T1 be the differing
8.675 * new and old parameter types (or old and new return types)
8.676 * for corresponding values passed by the new and old method types.
8.677 - * <p>
8.678 - * If an ordinary (non-varargs) parameter of the new type is
8.679 - * to be boxed in a varargs parameter of the old type of type T1[],
8.680 - * then T1 is the element type of the varargs array.
8.681 - * Otherwise, if a varargs parameter of the new type of type T0[]
8.682 - * is to be spread into one or more outgoing old type parameters,
8.683 - * then T0 is the element type of the
8.684 - * If the new type is varargs and the old type is not, the varargs
8.685 - * argument will be checked and must be a non-null array of exactly
8.686 - * the right length. If there are no parameters in the old type
8.687 - * corresponding to the new varargs parameter, the varargs argument
8.688 - * is also allowed to be null.
8.689 - * <p>
8.690 * Given those types T0, T1, one of the following conversions is applied
8.691 * if possible:
8.692 * <ul>
8.693 - * <li>If T0 and T1 are references, then a cast to T2 is applied,
8.694 - * where T2 is Object if T1 is an interface, else T1.
8.695 - * (The types do not need to be related in any particular way.
8.696 - * The treatment of interfaces follows the usage of the bytecode verifier.)
8.697 + * <li>If T0 and T1 are references, and T1 is not an interface type,
8.698 + * then a cast to T1 is applied.
8.699 + * (The types do not need to be related in any particular way.)
8.700 + * <li>If T0 and T1 are references, and T1 is an interface type,
8.701 + * then the value of type T0 is passed as a T1 without a cast.
8.702 + * (This treatment of interfaces follows the usage of the bytecode verifier.)
8.703 * <li>If T0 and T1 are primitives, then a Java casting
8.704 * conversion (JLS 5.5) is applied, if one exists.
8.705 * <li>If T0 and T1 are primitives and one is boolean,
8.706 @@ -745,16 +791,17 @@
8.707 * if necessary to T1 by one of the preceding conversions.
8.708 * Otherwise, T0 is converted directly to the wrapper type for T1,
8.709 * which is then unboxed.
8.710 - * <li>If T1 is void, any returned value is discarded
8.711 - * <li>If T0 is void and T1 a reference, a null value is introduced.
8.712 - * <li>If T0 is void and T1 a primitive, a zero value is introduced.
8.713 + * <li>If the return type T1 is void, any returned value is discarded
8.714 + * <li>If the return type T0 is void and T1 a reference, a null value is introduced.
8.715 + * <li>If the return type T0 is void and T1 a primitive, a zero value is introduced.
8.716 * </ul>
8.717 * @param target the method handle to invoke after arguments are retyped
8.718 * @param newType the expected type of the new method handle
8.719 * @return a method handle which delegates to {@code target} after performing
8.720 * any necessary argument conversions, and arranges for any
8.721 * necessary return value conversions
8.722 - * @throws WrongMethodTypeException if the conversion cannot be made
8.723 + * @throws IllegalArgumentException if the conversion cannot be made
8.724 + * @see MethodHandle#asType
8.725 */
8.726 public static
8.727 MethodHandle convertArguments(MethodHandle target, MethodType newType) {
8.728 @@ -872,23 +919,17 @@
8.729 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.730 * Produce a method handle which adapts the type of the
8.731 * given method handle to a new type, by collecting a series of
8.732 - * trailing arguments into an array.
8.733 - * The resulting method handle is guaranteed to confess a type
8.734 - * which is equal to the desired new type.
8.735 + * trailing arguments as elements to a single argument array.
8.736 * <p>
8.737 - * This method is inverse to {@link #spreadArguments}.
8.738 + * This method may be used as an inverse to {@link #spreadArguments}.
8.739 * The final parameter type of the old type must be an array type T[],
8.740 * which is the type of what is called the <i>spread</i> argument.
8.741 * The trailing arguments of the new type which correspond to
8.742 * the spread argument are all converted to type T and collected
8.743 * into an array before the original method is called.
8.744 - * <p>
8.745 - * ISSUE: Unify this with combineArguments. CollectArguments
8.746 - * is combineArguments with (a) new Object[]{...} as a combiner,
8.747 - * and (b) the combined arguments dropped, in favor of the combined result.
8.748 * @param target the method handle to invoke after the argument is prepended
8.749 * @param newType the expected type of the new method handle
8.750 - * @return a new method handle which collects some trailings argument
8.751 + * @return a new method handle which collects some trailing argument
8.752 * into an array, before calling the original method handle
8.753 */
8.754 public static
8.755 @@ -900,50 +941,72 @@
8.756 int numCollect = (inargs - collectPos);
8.757 if (collectPos < 0 || numCollect < 0)
8.758 throw newIllegalArgumentException("wrong number of arguments");
8.759 - return MethodHandleImpl.collectArguments(IMPL_TOKEN, target, newType, collectPos);
8.760 + MethodHandle res = MethodHandleImpl.collectArguments(IMPL_TOKEN, target, newType, collectPos, null);
8.761 + if (res == null) {
8.762 + throw newIllegalArgumentException("cannot collect from "+newType+" to " +oldType);
8.763 + }
8.764 + return res;
8.765 }
8.766
8.767 /**
8.768 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.769 - * Produce a method handle which calls the original method handle,
8.770 - * after inserting the given argument at the given position.
8.771 - * The type of the new method handle will drop the corresponding argument
8.772 - * type from the original handle's type.
8.773 + * Produce a method handle which calls the original method handle {@code target},
8.774 + * after inserting the given argument(s) at the given position.
8.775 + * The formal parameters to {@code target} which will be supplied by those
8.776 + * arguments are called <em>bound parameters</em>, because the new method
8.777 + * will contain bindings for those parameters take from {@code values}.
8.778 + * The type of the new method handle will drop the types for the bound
8.779 + * parameters from the original target type, since the new method handle
8.780 + * will no longer require those arguments to be supplied by its callers.
8.781 * <p>
8.782 - * The given argument object must match the dropped argument type.
8.783 - * If the dropped argument type is a primitive, the argument object
8.784 - * must be a wrapper, and is unboxed to produce the primitive.
8.785 + * Each given argument object must match the corresponding bound parameter type.
8.786 + * If a bound parameter type is a primitive, the argument object
8.787 + * must be a wrapper, and will be unboxed to produce the primitive value.
8.788 * <p>
8.789 * The <i>pos</i> may range between zero and <i>N</i> (inclusively),
8.790 - * where <i>N</i> is the number of argument types in <i>target</i>,
8.791 - * meaning to insert the new argument as the first or last (respectively),
8.792 - * or somewhere in between.
8.793 + * where <i>N</i> is the number of argument types in resulting method handle
8.794 + * (after bound parameter types are dropped).
8.795 * @param target the method handle to invoke after the argument is inserted
8.796 * @param pos where to insert the argument (zero for the first)
8.797 - * @param value the argument to insert
8.798 + * @param values the series of arguments to insert
8.799 * @return a new method handle which inserts an additional argument,
8.800 * before calling the original method handle
8.801 */
8.802 public static
8.803 - MethodHandle insertArgument(MethodHandle target, int pos, Object value) {
8.804 + MethodHandle insertArguments(MethodHandle target, int pos, Object... values) {
8.805 + int insCount = values.length;
8.806 MethodType oldType = target.type();
8.807 ArrayList<Class<?>> ptypes =
8.808 new ArrayList<Class<?>>(oldType.parameterList());
8.809 int outargs = oldType.parameterCount();
8.810 - int inargs = outargs - 1;
8.811 - if (pos < 0 || pos >= outargs)
8.812 + int inargs = outargs - insCount;
8.813 + if (inargs < 0)
8.814 + throw newIllegalArgumentException("too many values to insert");
8.815 + if (pos < 0 || pos > inargs)
8.816 throw newIllegalArgumentException("no argument type to append");
8.817 - Class<?> valueType = ptypes.remove(pos);
8.818 - value = checkValue(valueType, value);
8.819 - if (pos == 0 && !valueType.isPrimitive()) {
8.820 - // At least for now, make bound method handles a special case.
8.821 - // This lets us get by with minimal JVM support, at the expense
8.822 - // of generating signature-specific adapters as Java bytecodes.
8.823 - MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, target, value);
8.824 - if (bmh != null) return bmh;
8.825 - // else fall through to general adapter machinery
8.826 + MethodHandle result = target;
8.827 + for (int i = 0; i < insCount; i++) {
8.828 + Object value = values[i];
8.829 + Class<?> valueType = oldType.parameterType(pos+i);
8.830 + value = checkValue(valueType, value);
8.831 + if (pos == 0 && !valueType.isPrimitive()) {
8.832 + // At least for now, make bound method handles a special case.
8.833 + MethodHandle bmh = MethodHandleImpl.bindReceiver(IMPL_TOKEN, result, value);
8.834 + if (bmh != null) {
8.835 + result = bmh;
8.836 + continue;
8.837 + }
8.838 + // else fall through to general adapter machinery
8.839 + }
8.840 + result = MethodHandleImpl.bindArgument(IMPL_TOKEN, result, pos, value);
8.841 }
8.842 - return MethodHandleImpl.bindArgument(IMPL_TOKEN, target, pos, value);
8.843 + return result;
8.844 + }
8.845 +
8.846 + @Deprecated // "use MethodHandles.insertArguments instead"
8.847 + public static
8.848 + MethodHandle insertArgument(MethodHandle target, int pos, Object value) {
8.849 + return insertArguments(target, pos, value);
8.850 }
8.851
8.852 /**
8.853 @@ -953,10 +1016,25 @@
8.854 * The type of the new method handle will insert the given argument
8.855 * type(s), at that position, into the original handle's type.
8.856 * <p>
8.857 - * The <i>pos</i> may range between zero and <i>N-1</i>,
8.858 + * The <i>pos</i> may range between zero and <i>N</i>,
8.859 * where <i>N</i> is the number of argument types in <i>target</i>,
8.860 * meaning to drop the first or last argument (respectively),
8.861 * or an argument somewhere in between.
8.862 + * <p>
8.863 + * <b>Example:</b>
8.864 + * <p><blockquote><pre>
8.865 + * MethodHandle cat = MethodHandles.lookup().
8.866 + * findVirtual(String.class, "concat", String.class, String.class);
8.867 + * System.out.println(cat.<String>invoke("x", "y")); // xy
8.868 + * MethodHandle d0 = dropArguments(cat, 0, String.class);
8.869 + * System.out.println(d0.<String>invoke("x", "y", "z")); // xy
8.870 + * MethodHandle d1 = dropArguments(cat, 1, String.class);
8.871 + * System.out.println(d1.<String>invoke("x", "y", "z")); // xz
8.872 + * MethodHandle d2 = dropArguments(cat, 2, String.class);
8.873 + * System.out.println(d2.<String>invoke("x", "y", "z")); // yz
8.874 + * MethodHandle d12 = dropArguments(cat, 1, String.class, String.class);
8.875 + * System.out.println(d12.<String>invoke("w", "x", "y", "z")); // wz
8.876 + * </pre></blockquote>
8.877 * @param target the method handle to invoke after the argument is dropped
8.878 * @param valueTypes the type(s) of the argument to drop
8.879 * @param pos which argument to drop (zero for the first)
8.880 @@ -964,20 +1042,150 @@
8.881 * before calling the original method handle
8.882 */
8.883 public static
8.884 - MethodHandle dropArguments(MethodHandle target, int pos, Class<?>... valueTypes) {
8.885 - if (valueTypes.length == 0) return target;
8.886 + MethodHandle dropArguments(MethodHandle target, int pos, List<Class<?>> valueTypes) {
8.887 + if (valueTypes.size() == 0) return target;
8.888 MethodType oldType = target.type();
8.889 int outargs = oldType.parameterCount();
8.890 - int inargs = outargs + valueTypes.length;
8.891 + int inargs = outargs + valueTypes.size();
8.892 if (pos < 0 || pos >= inargs)
8.893 throw newIllegalArgumentException("no argument type to remove");
8.894 ArrayList<Class<?>> ptypes =
8.895 new ArrayList<Class<?>>(oldType.parameterList());
8.896 - ptypes.addAll(pos, Arrays.asList(valueTypes));
8.897 - MethodType newType = MethodType.make(oldType.returnType(), ptypes);
8.898 + ptypes.addAll(pos, valueTypes);
8.899 + MethodType newType = MethodType.methodType(oldType.returnType(), ptypes);
8.900 return MethodHandleImpl.dropArguments(IMPL_TOKEN, target, newType, pos);
8.901 }
8.902
8.903 + public static
8.904 + MethodHandle dropArguments(MethodHandle target, int pos, Class<?>... valueTypes) {
8.905 + return dropArguments(target, pos, Arrays.asList(valueTypes));
8.906 + }
8.907 +
8.908 + /**
8.909 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.910 + * Adapt a target method handle {@code target} by pre-processing
8.911 + * one or more of its arguments, each with its own unary filter function,
8.912 + * and then calling the target with each pre-processed argument
8.913 + * replaced by the result of its corresponding filter function.
8.914 + * <p>
8.915 + * The pre-processing is performed by one or more method handles,
8.916 + * specified in the non-null elements of the {@code filters} array.
8.917 + * (If there are no such elements, the original target is returned.)
8.918 + * Each filter (that is, each non-null element of {@code filters})
8.919 + * is applied to the corresponding argument of the adapter.
8.920 + * <p>
8.921 + * If a filter {@code F} applies to the {@code N}th argument of
8.922 + * the method handle, then {@code F} must be a method handle which
8.923 + * takes exactly one argument. The type of {@code F}'s sole argument
8.924 + * replaces the corresponding argument type of the target
8.925 + * in the resulting adapted method handle.
8.926 + * The return type of {@code F} must be identical to the corresponding
8.927 + * parameter type of the target.
8.928 + * <p>
8.929 + * It is an error if there are non-null elements of {@code filters}
8.930 + * which do not correspond to argument positions in the target.
8.931 + * The actual length of the target array may be any number, it need
8.932 + * not be the same as the parameter count of the target type.
8.933 + * (This provides an easy way to filter just the first argument or two
8.934 + * of a target method handle.)
8.935 + * <p> Here is pseudocode for the resulting adapter:
8.936 + * <blockquote><pre>
8.937 + * // there are N arguments in the A sequence
8.938 + * T target(A[N]...);
8.939 + * [i<N] V[i] filter[i](B[i]) = filters[i] ?: identity;
8.940 + * T adapter(B[N]... b) {
8.941 + * A[N] a...;
8.942 + * [i<N] a[i] = filter[i](b[i]);
8.943 + * return target(a...);
8.944 + * }
8.945 + * </pre></blockquote>
8.946 + * @param target the method handle to invoke after arguments are filtered
8.947 + * @param filters method handles to call initially on filtered arguments
8.948 + * @return method handle which incorporates the specified argument filtering logic
8.949 + * @throws IllegalArgumentException if a non-null element of {@code filters}
8.950 + * does not match a corresponding argument type of {@code target}
8.951 + */
8.952 + public static
8.953 + MethodHandle filterArguments(MethodHandle target, MethodHandle... filters) {
8.954 + MethodType targetType = target.type();
8.955 + MethodHandle adapter = target;
8.956 + MethodType adapterType = targetType;
8.957 + int pos = -1, maxPos = targetType.parameterCount();
8.958 + for (MethodHandle filter : filters) {
8.959 + pos += 1;
8.960 + if (filter == null) continue;
8.961 + if (pos >= maxPos)
8.962 + throw newIllegalArgumentException("too many filters");
8.963 + MethodType filterType = filter.type();
8.964 + if (filterType.parameterCount() != 1
8.965 + || filterType.returnType() != targetType.parameterType(pos))
8.966 + throw newIllegalArgumentException("target and filter types do not match");
8.967 + adapterType = adapterType.changeParameterType(pos, filterType.parameterType(0));
8.968 + adapter = MethodHandleImpl.filterArgument(IMPL_TOKEN, adapter, pos, filter);
8.969 + }
8.970 + MethodType midType = adapter.type();
8.971 + if (midType != adapterType)
8.972 + adapter = MethodHandleImpl.convertArguments(IMPL_TOKEN, adapter, adapterType, midType, null);
8.973 + return adapter;
8.974 + }
8.975 +
8.976 + /**
8.977 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.978 + * Adapt a target method handle {@code target} by pre-processing
8.979 + * some of its arguments, and then calling the target with
8.980 + * the result of the pre-processing, plus all original arguments.
8.981 + * <p>
8.982 + * The pre-processing is performed by a second method handle, the {@code combiner}.
8.983 + * The first {@code N} arguments passed to the adapter,
8.984 + * are copied to the combiner, which then produces a result.
8.985 + * (Here, {@code N} is defined as the parameter count of the adapter.)
8.986 + * After this, control passes to the {@code target}, with both the result
8.987 + * of the combiner, and all the original incoming arguments.
8.988 + * <p>
8.989 + * The first argument type of the target must be identical with the
8.990 + * return type of the combiner.
8.991 + * The resulting adapter is the same type as the target, except that the
8.992 + * initial argument type of the target is dropped.
8.993 + * <p>
8.994 + * (Note that {@link #dropArguments} can be used to remove any arguments
8.995 + * that either the {@code combiner} or {@code target} does not wish to receive.
8.996 + * If some of the incoming arguments are destined only for the combiner,
8.997 + * consider using {@link #collectArguments} instead, since those
8.998 + * arguments will not need to be live on the stack on entry to the
8.999 + * target.)
8.1000 + * <p>
8.1001 + * The first argument of the target must be identical with the
8.1002 + * return value of the combiner.
8.1003 + * <p> Here is pseudocode for the resulting adapter:
8.1004 + * <blockquote><pre>
8.1005 + * // there are N arguments in the A sequence
8.1006 + * T target(V, A[N]..., B...);
8.1007 + * V combiner(A...);
8.1008 + * T adapter(A... a, B... b) {
8.1009 + * V v = combiner(a...);
8.1010 + * return target(v, a..., b...);
8.1011 + * }
8.1012 + * </pre></blockquote>
8.1013 + * @param target the method handle to invoke after arguments are combined
8.1014 + * @param combiner method handle to call initially on the incoming arguments
8.1015 + * @return method handle which incorporates the specified argument folding logic
8.1016 + * @throws IllegalArgumentException if the first argument type of
8.1017 + * {@code target} is not the same as {@code combiner}'s return type,
8.1018 + * or if the next {@code foldArgs} argument types of {@code target}
8.1019 + * are not identical with the argument types of {@code combiner}
8.1020 + */
8.1021 + public static
8.1022 + MethodHandle foldArguments(MethodHandle target, MethodHandle combiner) {
8.1023 + MethodType targetType = target.type();
8.1024 + MethodType combinerType = combiner.type();
8.1025 + int foldArgs = combinerType.parameterCount();
8.1026 + boolean ok = (targetType.parameterCount() >= 1 + foldArgs);
8.1027 + if (!ok)
8.1028 + throw misMatchedTypes("target and combiner types", targetType, combinerType);
8.1029 + MethodType newType = targetType.dropParameterTypes(0, 1);
8.1030 + return MethodHandleImpl.foldArguments(IMPL_TOKEN, target, newType, combiner);
8.1031 + }
8.1032 +
8.1033 /**
8.1034 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.1035 * Make a method handle which adapts a target method handle,
8.1036 @@ -985,18 +1193,18 @@
8.1037 * If the guard fails, a fallback handle is called instead.
8.1038 * All three method handles must have the same corresponding
8.1039 * argument and return types, except that the return type
8.1040 - * of the test must be boolean.
8.1041 + * of the test must be boolean, and the test is allowed
8.1042 + * to have fewer arguments than the other two method handles.
8.1043 * <p> Here is pseudocode for the resulting adapter:
8.1044 * <blockquote><pre>
8.1045 - * signature T(A...);
8.1046 * boolean test(A...);
8.1047 - * T target(A...);
8.1048 - * T fallback(A...);
8.1049 - * T adapter(A... a) {
8.1050 + * T target(A...,B...);
8.1051 + * T fallback(A...,B...);
8.1052 + * T adapter(A... a,B... b) {
8.1053 * if (test(a...))
8.1054 - * return target(a...);
8.1055 + * return target(a..., b...);
8.1056 * else
8.1057 - * return fallback(a...);
8.1058 + * return fallback(a..., b...);
8.1059 * }
8.1060 * </pre></blockquote>
8.1061 * @param test method handle used for test, must return boolean
8.1062 @@ -1011,10 +1219,23 @@
8.1063 MethodHandle guardWithTest(MethodHandle test,
8.1064 MethodHandle target,
8.1065 MethodHandle fallback) {
8.1066 - if (target.type() != fallback.type())
8.1067 - throw newIllegalArgumentException("target and fallback types do not match");
8.1068 - if (target.type().changeReturnType(boolean.class) != test.type())
8.1069 - throw newIllegalArgumentException("target and test types do not match");
8.1070 + MethodType gtype = test.type();
8.1071 + MethodType ttype = target.type();
8.1072 + MethodType ftype = fallback.type();
8.1073 + if (ttype != ftype)
8.1074 + throw misMatchedTypes("target and fallback types", ttype, ftype);
8.1075 + MethodType gtype2 = ttype.changeReturnType(boolean.class);
8.1076 + if (gtype2 != gtype) {
8.1077 + if (gtype.returnType() != boolean.class)
8.1078 + throw newIllegalArgumentException("guard type is not a predicate "+gtype);
8.1079 + int gpc = gtype.parameterCount(), tpc = ttype.parameterCount();
8.1080 + if (gpc < tpc) {
8.1081 + test = dropArguments(test, gpc, ttype.parameterList().subList(gpc, tpc));
8.1082 + gtype = test.type();
8.1083 + }
8.1084 + if (gtype2 != gtype)
8.1085 + throw misMatchedTypes("target and test types", ttype, gtype);
8.1086 + }
8.1087 /* {
8.1088 MethodHandle invoke = findVirtual(MethodHandle.class, "invoke", target.type());
8.1089 static MethodHandle choose(boolean z, MethodHandle t, MethodHandle f) {
8.1090 @@ -1027,7 +1248,7 @@
8.1091 }
8.1092 // choose = \z.(z ? target : fallback)
8.1093 MethodHandle choose = findVirtual(MethodHandles.class, "choose",
8.1094 - MethodType.make(boolean.class, MethodHandle.class, MethodHandle.class));
8.1095 + MethodType.methodType(boolean.class, MethodHandle.class, MethodHandle.class));
8.1096 choose = appendArgument(choose, target);
8.1097 choose = appendArgument(choose, fallback);
8.1098 MethodHandle dispatch = compose(choose, test);
8.1099 @@ -1038,67 +1259,88 @@
8.1100 return MethodHandleImpl.makeGuardWithTest(IMPL_TOKEN, test, target, fallback);
8.1101 }
8.1102
8.1103 + static RuntimeException misMatchedTypes(String what, MethodType t1, MethodType t2) {
8.1104 + return newIllegalArgumentException(what + " must match: " + t1 + " != " + t2);
8.1105 + }
8.1106 +
8.1107 /**
8.1108 * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
8.1109 - * Adapt a target method handle {@code target} by first processing
8.1110 - * its arguments, and then calling the target.
8.1111 - * The initial processing is performed by a second method handle, the {@code combiner}.
8.1112 - * After this, control passes to the {@code target}, with the same arguments.
8.1113 + * Make a method handle which adapts a target method handle,
8.1114 + * by running it inside an exception handler.
8.1115 + * If the target returns normally, the adapter returns that value.
8.1116 + * If an exception matching the specified type is thrown, the fallback
8.1117 + * handle is called instead on the exception, plus the original arguments.
8.1118 * <p>
8.1119 - * The return value of the {@code combiner} is inserted into the argument list
8.1120 - * for the {@code target} at the indicated position {@code pos}, if it is non-negative.
8.1121 - * Except for this inserted argument (if any), the argument types of
8.1122 - * the target {@code target} and the {@code combiner} must be identical.
8.1123 - * <p>
8.1124 - * (Note that {@link #dropArguments} can be used to remove any arguments
8.1125 - * that either the {@code combiner} or {@code target} does not wish to receive.)
8.1126 - * <p>
8.1127 - * The combiner handle must have the same argument types as the
8.1128 - * target handle, but must return {@link MethodHandle} instead of
8.1129 - * the ultimate return type. The returned method handle, in turn,
8.1130 - * is required to have exactly the given final method type.
8.1131 + * The handler must have leading parameter of {@code exType} or a supertype,
8.1132 + * followed by arguments which correspond <em>(how? TBD)</em> to
8.1133 + * all the parameters of the target.
8.1134 + * The target and handler must return the same type.
8.1135 * <p> Here is pseudocode for the resulting adapter:
8.1136 * <blockquote><pre>
8.1137 - * signature V(A[pos]..., B...);
8.1138 - * signature T(A[pos]..., V, B...);
8.1139 - * T target(A... a, V v, B... b);
8.1140 - * V combiner(A..., B...);
8.1141 - * T adapter(A... a, B... b) {
8.1142 - * V v = combiner(a..., b...);
8.1143 - * return target(a..., v, b...);
8.1144 + * T target(A...);
8.1145 + * T handler(ExType, A...);
8.1146 + * T adapter(A... a) {
8.1147 + * try {
8.1148 + * return target(a...);
8.1149 + * } catch (ExType ex) {
8.1150 + * return handler(ex, a...);
8.1151 + * }
8.1152 * }
8.1153 * </pre></blockquote>
8.1154 - * @param target the method handle to invoke after arguments are combined
8.1155 - * @param pos where the return value of {@code combiner} is to
8.1156 - * be inserted as an argument to {@code target}
8.1157 - * @param combiner method handle to call initially on the incoming arguments
8.1158 - * @return method handle which incorporates the specified dispatch logic
8.1159 - * @throws IllegalArgumentException if {@code combiner} does not itself
8.1160 - * return either void or the {@code pos}-th argument of {@code target},
8.1161 - * or does not have the same argument types as {@code target}
8.1162 - * (minus the inserted argument)
8.1163 + * @param target method handle to call
8.1164 + * @param exType the type of exception which the handler will catch
8.1165 + * @param handler method handle to call if a matching exception is thrown
8.1166 + * @return method handle which incorporates the specified try/catch logic
8.1167 + * @throws IllegalArgumentException if {@code handler} does not accept
8.1168 + * the given exception type, or if the method handle types do
8.1169 + * not match in their return types and their
8.1170 + * corresponding parameters
8.1171 */
8.1172 public static
8.1173 - MethodHandle combineArguments(MethodHandle target, int pos, MethodHandle combiner) {
8.1174 - MethodType mhType = target.type();
8.1175 - Class<?> combineType = combiner.type().returnType();
8.1176 - MethodType incomingArgs;
8.1177 - if (pos < 0) {
8.1178 - // No inserted argument; target & combiner must have same argument types.
8.1179 - incomingArgs = mhType;
8.1180 - if (!incomingArgs.changeReturnType(combineType).equals(combiner.type()))
8.1181 - throw newIllegalArgumentException("target and combiner types do not match");
8.1182 - } else {
8.1183 - // Inserted argument.
8.1184 - if (pos >= mhType.parameterCount()
8.1185 - || mhType.parameterType(pos) != combineType)
8.1186 - throw newIllegalArgumentException("inserted combiner argument does not match target");
8.1187 - incomingArgs = mhType.dropParameterType(pos);
8.1188 - }
8.1189 - if (!incomingArgs.changeReturnType(combineType).equals(combiner.type())) {
8.1190 - throw newIllegalArgumentException("target and combiner types do not match");
8.1191 - }
8.1192 - return MethodHandleImpl.combineArguments(IMPL_TOKEN, target, combiner, pos);
8.1193 + MethodHandle catchException(MethodHandle target,
8.1194 + Class<? extends Throwable> exType,
8.1195 + MethodHandle handler) {
8.1196 + MethodType targetType = target.type();
8.1197 + MethodType handlerType = handler.type();
8.1198 + boolean ok = (targetType.parameterCount() ==
8.1199 + handlerType.parameterCount() - 1);
8.1200 +// for (int i = 0; ok && i < numExArgs; i++) {
8.1201 +// if (targetType.parameterType(i) != handlerType.parameterType(1+i))
8.1202 +// ok = false;
8.1203 +// }
8.1204 + if (!ok)
8.1205 + throw newIllegalArgumentException("target and handler types do not match");
8.1206 + return MethodHandleImpl.makeGuardWithCatch(IMPL_TOKEN, target, exType, handler);
8.1207 }
8.1208
8.1209 + /**
8.1210 + * Produce a method handle which will throw exceptions of the given {@code exType}.
8.1211 + * The method handle will accept a single argument of {@code exType},
8.1212 + * and immediately throw it as an exception.
8.1213 + * The method type will nominally specify a return of {@code returnType}.
8.1214 + * The return type may be anything convenient: It doesn't matter to the
8.1215 + * method handle's behavior, since it will never return normally.
8.1216 + */
8.1217 + public static
8.1218 + MethodHandle throwException(Class<?> returnType, Class<? extends Throwable> exType) {
8.1219 + return MethodHandleImpl.throwException(IMPL_TOKEN, MethodType.methodType(returnType, exType));
8.1220 + }
8.1221 +
8.1222 + /** Alias for {@link MethodType#methodType}. */
8.1223 + @Deprecated // "use MethodType.methodType instead"
8.1224 + public static MethodType methodType(Class<?> rtype) {
8.1225 + return MethodType.methodType(rtype);
8.1226 + }
8.1227 +
8.1228 + /** Alias for {@link MethodType#methodType}. */
8.1229 + @Deprecated // "use MethodType.methodType instead"
8.1230 + public static MethodType methodType(Class<?> rtype, Class<?> ptype) {
8.1231 + return MethodType.methodType(rtype, ptype);
8.1232 + }
8.1233 +
8.1234 + /** Alias for {@link MethodType#methodType}. */
8.1235 + @Deprecated // "use MethodType.methodType instead"
8.1236 + public static MethodType methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes) {
8.1237 + return MethodType.methodType(rtype, ptype0, ptypes);
8.1238 + }
8.1239 }
9.1 --- a/src/share/classes/java/dyn/MethodType.java Tue Jan 05 10:40:44 2010 +0800
9.2 +++ b/src/share/classes/java/dyn/MethodType.java Wed Jan 13 15:16:06 2010 -0800
9.3 @@ -32,7 +32,7 @@
9.4 import sun.dyn.Access;
9.5 import sun.dyn.Invokers;
9.6 import sun.dyn.MethodTypeImpl;
9.7 -import sun.dyn.util.BytecodeSignature;
9.8 +import sun.dyn.util.BytecodeDescriptor;
9.9 import static sun.dyn.MemberName.newIllegalArgumentException;
9.10
9.11 /**
9.12 @@ -63,7 +63,7 @@
9.13
9.14 static {
9.15 // This hack allows the implementation package special access to
9.16 - // the internals of MethodType. In particular, the Form has all sorts
9.17 + // the internals of MethodType. In particular, the MTImpl has all sorts
9.18 // of cached information useful to the implementation code.
9.19 MethodTypeImpl.setMethodTypeFriend(IMPL_TOKEN, new MethodTypeImpl.MethodTypeFriend() {
9.20 public Class<?>[] ptypes(MethodType mt) { return mt.ptypes; }
9.21 @@ -114,50 +114,75 @@
9.22 * @throws IllegalArgumentException if any of the ptypes is void
9.23 */
9.24 public static
9.25 - MethodType make(Class<?> rtype, Class<?>[] ptypes) {
9.26 + MethodType methodType(Class<?> rtype, Class<?>[] ptypes) {
9.27 return makeImpl(rtype, ptypes, false);
9.28 }
9.29 -
9.30 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}. */
9.31 - public static
9.32 - MethodType make(Class<?> rtype, List<? extends Class<?>> ptypes) {
9.33 - return makeImpl(rtype, ptypes.toArray(NO_PTYPES), true);
9.34 + @Deprecated public static
9.35 + MethodType make(Class<?> rtype, Class<?>[] ptypes) {
9.36 + return methodType(rtype, ptypes);
9.37 }
9.38
9.39 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.40 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}. */
9.41 + public static
9.42 + MethodType methodType(Class<?> rtype, List<? extends Class<?>> ptypes) {
9.43 + boolean notrust = false; // random List impl. could return evil ptypes array
9.44 + return makeImpl(rtype, ptypes.toArray(NO_PTYPES), notrust);
9.45 + }
9.46 + @Deprecated public static
9.47 + MethodType make(Class<?> rtype, List<? extends Class<?>> ptypes) {
9.48 + return methodType(rtype, ptypes);
9.49 + }
9.50 +
9.51 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.52 * The leading parameter type is prepended to the remaining array.
9.53 */
9.54 public static
9.55 - MethodType make(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes) {
9.56 + MethodType methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes) {
9.57 Class<?>[] ptypes1 = new Class<?>[1+ptypes.length];
9.58 ptypes1[0] = ptype0;
9.59 System.arraycopy(ptypes, 0, ptypes1, 1, ptypes.length);
9.60 return makeImpl(rtype, ptypes1, true);
9.61 }
9.62 + @Deprecated public static
9.63 + MethodType make(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes) {
9.64 + return methodType(rtype, ptype0, ptypes);
9.65 + }
9.66
9.67 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.68 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.69 * The resulting method has no parameter types.
9.70 */
9.71 public static
9.72 - MethodType make(Class<?> rtype) {
9.73 + MethodType methodType(Class<?> rtype) {
9.74 return makeImpl(rtype, NO_PTYPES, true);
9.75 }
9.76 + @Deprecated public static
9.77 + MethodType make(Class<?> rtype) {
9.78 + return methodType(rtype);
9.79 + }
9.80
9.81 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.82 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.83 * The resulting method has the single given parameter type.
9.84 */
9.85 public static
9.86 - MethodType make(Class<?> rtype, Class<?> ptype0) {
9.87 + MethodType methodType(Class<?> rtype, Class<?> ptype0) {
9.88 return makeImpl(rtype, new Class<?>[]{ ptype0 }, true);
9.89 }
9.90 + @Deprecated public static
9.91 + MethodType make(Class<?> rtype, Class<?> ptype0) {
9.92 + return methodType(rtype, ptype0);
9.93 + }
9.94
9.95 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.96 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.97 * The resulting method has the same parameter types as {@code ptypes},
9.98 * and the specified return type.
9.99 */
9.100 public static
9.101 + MethodType methodType(Class<?> rtype, MethodType ptypes) {
9.102 + return makeImpl(rtype, ptypes.ptypes, true);
9.103 + }
9.104 + @Deprecated public static
9.105 MethodType make(Class<?> rtype, MethodType ptypes) {
9.106 - return makeImpl(rtype, ptypes.ptypes, true);
9.107 + return methodType(rtype, ptypes);
9.108 }
9.109
9.110 /**
9.111 @@ -202,15 +227,16 @@
9.112 private static final MethodType[] objectOnlyTypes = new MethodType[20];
9.113
9.114 /**
9.115 - * Convenience method for {@link #make(java.lang.Class, java.lang.Class[], boolean)}.
9.116 - * All parameters and the return type will be Object, except the final varargs parameter if any.
9.117 + * Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.118 + * All parameters and the return type will be {@code Object},
9.119 + * except the final varargs parameter if any, which will be {@code Object[]}.
9.120 * @param objectArgCount number of parameters (excluding the varargs parameter if any)
9.121 - * @param varargs whether there will be a varargs parameter, of type Object[]
9.122 + * @param varargs whether there will be a varargs parameter, of type {@code Object[]}
9.123 * @return a totally generic method type, given only its count of parameters and varargs
9.124 - * @see #makeGeneric(int)
9.125 + * @see #genericMethodType(int)
9.126 */
9.127 public static
9.128 - MethodType makeGeneric(int objectArgCount, boolean varargs) {
9.129 + MethodType genericMethodType(int objectArgCount, boolean varargs) {
9.130 MethodType mt;
9.131 int ivarargs = (!varargs ? 0 : 1);
9.132 int ootIndex = objectArgCount*2 + ivarargs;
9.133 @@ -227,19 +253,27 @@
9.134 }
9.135 return mt;
9.136 }
9.137 + @Deprecated public static
9.138 + MethodType makeGeneric(int objectArgCount, boolean varargs) {
9.139 + return genericMethodType(objectArgCount, varargs);
9.140 + }
9.141
9.142 /**
9.143 * All parameters and the return type will be Object.
9.144 * @param objectArgCount number of parameters
9.145 * @return a totally generic method type, given only its count of parameters
9.146 - * @see #makeGeneric(int, boolean)
9.147 + * @see #genericMethodType(int, boolean)
9.148 */
9.149 public static
9.150 + MethodType genericMethodType(int objectArgCount) {
9.151 + return genericMethodType(objectArgCount, false);
9.152 + }
9.153 + @Deprecated public static
9.154 MethodType makeGeneric(int objectArgCount) {
9.155 - return makeGeneric(objectArgCount, false);
9.156 + return genericMethodType(objectArgCount);
9.157 }
9.158
9.159 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[], boolean)}.
9.160 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.161 * @param num the index (zero-based) of the parameter type to change
9.162 * @param nptype a new parameter type to replace the old one with
9.163 * @return the same type, except with the selected parameter changed
9.164 @@ -251,11 +285,10 @@
9.165 return makeImpl(rtype, nptypes, true);
9.166 }
9.167
9.168 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[], boolean)}.
9.169 - * @param num the position (zero-based) of the inserted parameter type
9.170 - * @param nptype a new parameter type to insert into the parameter list
9.171 - * @return the same type, except with the selected parameter inserted
9.172 + /** Convenience method for {@link #insertParameterTypes}.
9.173 + * @deprecated Use {@link #insertParameterTypes} instead.
9.174 */
9.175 + @Deprecated
9.176 public MethodType insertParameterType(int num, Class<?> nptype) {
9.177 int len = ptypes.length;
9.178 Class<?>[] nptypes = Arrays.copyOfRange(ptypes, 0, len+1);
9.179 @@ -264,23 +297,73 @@
9.180 return makeImpl(rtype, nptypes, true);
9.181 }
9.182
9.183 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[], boolean)}.
9.184 - * @param num the index (zero-based) of the parameter type to remove
9.185 - * @return the same type, except with the selected parameter removed
9.186 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.187 + * @param num the position (zero-based) of the inserted parameter type(s)
9.188 + * @param ptypesToInsert zero or more a new parameter types to insert into the parameter list
9.189 + * @return the same type, except with the selected parameter(s) inserted
9.190 */
9.191 - public MethodType dropParameterType(int num) {
9.192 + public MethodType insertParameterTypes(int num, Class<?>... ptypesToInsert) {
9.193 int len = ptypes.length;
9.194 + if (num < 0 || num > len)
9.195 + throw newIllegalArgumentException("num="+num); //SPECME
9.196 + int ilen = ptypesToInsert.length;
9.197 + if (ilen == 0) return this;
9.198 + Class<?>[] nptypes = Arrays.copyOfRange(ptypes, 0, len+ilen);
9.199 + System.arraycopy(nptypes, num, nptypes, num+ilen, len-num);
9.200 + System.arraycopy(ptypesToInsert, 0, nptypes, num, ilen);
9.201 + return makeImpl(rtype, nptypes, true);
9.202 + }
9.203 +
9.204 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.205 + * @param num the position (zero-based) of the inserted parameter type(s)
9.206 + * @param ptypesToInsert zero or more a new parameter types to insert into the parameter list
9.207 + * @return the same type, except with the selected parameter(s) inserted
9.208 + */
9.209 + public MethodType insertParameterTypes(int num, List<Class<?>> ptypesToInsert) {
9.210 + return insertParameterTypes(num, ptypesToInsert.toArray(NO_PTYPES));
9.211 + }
9.212 +
9.213 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.214 + * @param start the index (zero-based) of the first parameter type to remove
9.215 + * @param end the index (greater than {@code start}) of the first parameter type after not to remove
9.216 + * @return the same type, except with the selected parameter(s) removed
9.217 + */
9.218 + public MethodType dropParameterTypes(int start, int end) {
9.219 + int len = ptypes.length;
9.220 + if (!(0 <= start && start <= end && end <= len))
9.221 + throw newIllegalArgumentException("start="+start+" end="+end); //SPECME
9.222 + if (start == end) return this;
9.223 Class<?>[] nptypes;
9.224 - if (num == 0) {
9.225 - nptypes = Arrays.copyOfRange(ptypes, 1, len);
9.226 + if (start == 0) {
9.227 + if (end == len) {
9.228 + // drop all parameters
9.229 + nptypes = NO_PTYPES;
9.230 + } else {
9.231 + // drop initial parameter(s)
9.232 + nptypes = Arrays.copyOfRange(ptypes, end, len);
9.233 + }
9.234 } else {
9.235 - nptypes = Arrays.copyOfRange(ptypes, 0, len-1);
9.236 - System.arraycopy(ptypes, num+1, nptypes, num, (len-1)-num);
9.237 + if (end == len) {
9.238 + // drop trailing parameter(s)
9.239 + nptypes = Arrays.copyOfRange(ptypes, 0, start);
9.240 + } else {
9.241 + int tail = len - end;
9.242 + nptypes = Arrays.copyOfRange(ptypes, 0, start + tail);
9.243 + System.arraycopy(ptypes, end, nptypes, start, tail);
9.244 + }
9.245 }
9.246 return makeImpl(rtype, nptypes, true);
9.247 }
9.248
9.249 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[], boolean)}.
9.250 + /** Convenience method for {@link #dropParameterTypes}.
9.251 + * @deprecated Use {@link #dropParameterTypes} instead.
9.252 + */
9.253 + @Deprecated
9.254 + public MethodType dropParameterType(int num) {
9.255 + return dropParameterTypes(num, num+1);
9.256 + }
9.257 +
9.258 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.259 * @param nrtype a return parameter type to replace the old one with
9.260 * @return the same type, except with the return type change
9.261 */
9.262 @@ -291,6 +374,7 @@
9.263
9.264 /** Convenience method.
9.265 * Report if this type contains a primitive argument or return value.
9.266 + * The return type {@code void} counts as a primitive.
9.267 * @return true if any of the types are primitives
9.268 */
9.269 public boolean hasPrimitives() {
9.270 @@ -300,39 +384,47 @@
9.271 /** Convenience method.
9.272 * Report if this type contains a wrapper argument or return value.
9.273 * Wrappers are types which box primitive values, such as {@link Integer}.
9.274 + * The reference type {@code java.lang.Void} counts as a wrapper.
9.275 * @return true if any of the types are wrappers
9.276 */
9.277 public boolean hasWrappers() {
9.278 return unwrap() != this;
9.279 }
9.280
9.281 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.282 - * Erase all reference types to Object.
9.283 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.284 + * Erase all reference types to {@code Object}.
9.285 + * All primitive types (including {@code void}) will remain unchanged.
9.286 * @return a version of the original type with all reference types replaced
9.287 */
9.288 public MethodType erase() {
9.289 return form.erasedType();
9.290 }
9.291
9.292 - /** Convenience method for {@link #makeGeneric(int)}.
9.293 - * Convert all types, both reference and primitive, to Object.
9.294 + /** Convenience method for {@link #genericMethodType(int)}.
9.295 + * Convert all types, both reference and primitive, to {@code Object}.
9.296 + * The expression {@code type.wrap().erase()} produces the same value
9.297 + * as {@code type.generic()}.
9.298 * @return a version of the original type with all types replaced
9.299 */
9.300 public MethodType generic() {
9.301 - return makeGeneric(parameterCount());
9.302 + return genericMethodType(parameterCount());
9.303 }
9.304
9.305 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.306 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.307 * Convert all primitive types to their corresponding wrapper types.
9.308 + * All reference types (including wrapper types) will remain unchanged.
9.309 * A {@code void} return type is changed to the type {@code java.lang.Void}.
9.310 + * The expression {@code type.wrap().erase()} produces the same value
9.311 + * as {@code type.generic()}.
9.312 * @return a version of the original type with all primitive types replaced
9.313 */
9.314 public MethodType wrap() {
9.315 return hasPrimitives() ? wrapWithPrims(this) : this;
9.316 }
9.317
9.318 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.319 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.320 * Convert all wrapper types to their corresponding primitive types.
9.321 + * All primitive types (including {@code void}) will remain unchanged.
9.322 * A return type of {@code java.lang.Void} is changed to {@code void}.
9.323 * @return a version of the original type with all wrapper types replaced
9.324 */
9.325 @@ -391,6 +483,7 @@
9.326
9.327 /**
9.328 * Convenience method to present the arguments as an array.
9.329 + * Changes to the array will not result in changes to the type.
9.330 * @return the parameter types (as a fresh copy if necessary)
9.331 */
9.332 public Class<?>[] parameterArray() {
9.333 @@ -491,7 +584,7 @@
9.334 return form.parameterSlotCount();
9.335 }
9.336
9.337 - /** Number of JVM stack slots which carry all parameters after
9.338 + /** Number of JVM stack slots which carry all parameters including and after
9.339 * the given position, which must be in the range of 0 to
9.340 * {@code parameterCount} inclusive. Successive parameters are
9.341 * more shallowly stacked, and parameters are indexed in the bytecodes
9.342 @@ -532,7 +625,7 @@
9.343 return form.returnSlotCount();
9.344 }
9.345
9.346 - /** Convenience method for {@link #make(java.lang.Class, java.lang.Class[])}.
9.347 + /** Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[])}.
9.348 * Find or create an instance (interned) of the given method type.
9.349 * Any class or interface name embedded in the signature string
9.350 * will be resolved by calling {@link ClassLoader#loadClass(java.lang.String)}
9.351 @@ -544,16 +637,16 @@
9.352 * <p>
9.353 * This method is included for the benfit of applications that must
9.354 * generate bytecodes that process method handles and invokedynamic.
9.355 - * @param bytecodeSignature a bytecode-level signature string "(T...)T"
9.356 + * @param descriptor a bytecode-level signature string "(T...)T"
9.357 * @param loader the class loader in which to look up the types
9.358 * @return a method type matching the bytecode-level signature
9.359 * @throws IllegalArgumentException if the string is not well-formed
9.360 * @throws TypeNotPresentException if a named type cannot be found
9.361 */
9.362 - public static MethodType fromBytecodeString(String bytecodeSignature, ClassLoader loader)
9.363 + public static MethodType fromMethodDescriptorString(String descriptor, ClassLoader loader)
9.364 throws IllegalArgumentException, TypeNotPresentException
9.365 {
9.366 - List<Class<?>> types = BytecodeSignature.parseMethod(bytecodeSignature, loader);
9.367 + List<Class<?>> types = BytecodeDescriptor.parseMethod(descriptor, loader);
9.368 Class<?> rtype = types.remove(types.size() - 1);
9.369 Class<?>[] ptypes = types.toArray(NO_PTYPES);
9.370 return makeImpl(rtype, ptypes, true);
9.371 @@ -565,11 +658,21 @@
9.372 * <p>
9.373 * This method is included for the benfit of applications that must
9.374 * generate bytecodes that process method handles and invokedynamic.
9.375 - * {@link #fromBytecodeString(java.lang.String, java.lang.ClassLoader)},
9.376 + * {@link #fromMethodDescriptorString(java.lang.String, java.lang.ClassLoader)},
9.377 * because the latter requires a suitable class loader argument.
9.378 * @return the bytecode signature representation
9.379 */
9.380 + public String toMethodDescriptorString() {
9.381 + return BytecodeDescriptor.unparse(this);
9.382 + }
9.383 +
9.384 + /** Temporary alias for toMethodDescriptorString; delete after M3. */
9.385 public String toBytecodeString() {
9.386 - return BytecodeSignature.unparse(this);
9.387 + return toMethodDescriptorString();
9.388 + }
9.389 + /** Temporary alias for fromMethodDescriptorString; delete after M3. */
9.390 + public static MethodType fromBytecodeString(String descriptor, ClassLoader loader)
9.391 + throws IllegalArgumentException, TypeNotPresentException {
9.392 + return fromMethodDescriptorString(descriptor, loader);
9.393 }
9.394 }
10.1 --- a/src/share/classes/java/dyn/package-info.java Tue Jan 05 10:40:44 2010 +0800
10.2 +++ b/src/share/classes/java/dyn/package-info.java Wed Jan 13 15:16:06 2010 -0800
10.3 @@ -24,6 +24,7 @@
10.4 */
10.5
10.6 /**
10.7 + * <em>PROVISIONAL API, WORK IN PROGRESS:</em>
10.8 * This package contains dynamic language support provided directly by
10.9 * the Java core class libraries and virtual machine.
10.10 * @author John Rose, JSR 292 EG
11.1 --- a/src/share/classes/sun/dyn/AdapterMethodHandle.java Tue Jan 05 10:40:44 2010 +0800
11.2 +++ b/src/share/classes/sun/dyn/AdapterMethodHandle.java Wed Jan 13 15:16:06 2010 -0800
11.3 @@ -30,7 +30,7 @@
11.4 import java.dyn.*;
11.5 import java.util.Arrays;
11.6 import static sun.dyn.MethodHandleNatives.Constants.*;
11.7 -import static sun.dyn.MethodHandleImpl.newIllegalArgumentException;
11.8 +import static sun.dyn.MemberName.newIllegalArgumentException;
11.9
11.10 /**
11.11 * This method handle performs simple conversion or checking of a single argument.
11.12 @@ -302,7 +302,22 @@
11.13 */
11.14 private static int type2size(int type) {
11.15 assert(type >= T_BOOLEAN && type <= T_OBJECT);
11.16 - return (type == T_FLOAT || type == T_DOUBLE) ? 2 : 1;
11.17 + return (type == T_LONG || type == T_DOUBLE) ? 2 : 1;
11.18 + }
11.19 + private static int type2size(Class<?> type) {
11.20 + return type2size(basicType(type));
11.21 + }
11.22 +
11.23 + /** The given stackMove is the number of slots pushed.
11.24 + * It might be negative. Scale it (multiply) by the
11.25 + * VM's notion of how an address changes with a push,
11.26 + * to get the raw SP change for stackMove.
11.27 + * Then shift and mask it into the correct field.
11.28 + */
11.29 + private static long insertStackMove(int stackMove) {
11.30 + // following variable must be long to avoid sign extension after '<<'
11.31 + long spChange = stackMove * MethodHandleNatives.JVM_STACK_MOVE_UNIT;
11.32 + return (spChange & CONV_STACK_MOVE_MASK) << CONV_STACK_MOVE_SHIFT;
11.33 }
11.34
11.35 /** Construct an adapter conversion descriptor for a single-argument conversion. */
11.36 @@ -310,16 +325,16 @@
11.37 assert(src == (src & 0xF));
11.38 assert(dest == (dest & 0xF));
11.39 assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF);
11.40 - long stackMove = type2size(dest) - type2size(src);
11.41 + int stackMove = type2size(dest) - type2size(src);
11.42 return ((long) argnum << 32 |
11.43 (long) convOp << CONV_OP_SHIFT |
11.44 (int) src << CONV_SRC_TYPE_SHIFT |
11.45 (int) dest << CONV_DEST_TYPE_SHIFT |
11.46 - stackMove << CONV_STACK_MOVE_SHIFT
11.47 + insertStackMove(stackMove)
11.48 );
11.49 }
11.50 private static long makeConv(int convOp, int argnum, int stackMove) {
11.51 - assert(convOp >= OP_SWAP_ARGS && convOp <= OP_SPREAD_ARGS);
11.52 + assert(convOp >= OP_DUP_ARGS && convOp <= OP_SPREAD_ARGS);
11.53 byte src = 0, dest = 0;
11.54 if (convOp >= OP_COLLECT_ARGS && convOp <= OP_SPREAD_ARGS)
11.55 src = dest = T_OBJECT;
11.56 @@ -327,12 +342,21 @@
11.57 (long) convOp << CONV_OP_SHIFT |
11.58 (int) src << CONV_SRC_TYPE_SHIFT |
11.59 (int) dest << CONV_DEST_TYPE_SHIFT |
11.60 - stackMove << CONV_STACK_MOVE_SHIFT
11.61 + insertStackMove(stackMove)
11.62 + );
11.63 + }
11.64 + private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) {
11.65 + assert(convOp >= OP_SWAP_ARGS && convOp <= OP_ROT_ARGS);
11.66 + return ((long) srcArg << 32 |
11.67 + (long) convOp << CONV_OP_SHIFT |
11.68 + (int) type << CONV_SRC_TYPE_SHIFT |
11.69 + (int) type << CONV_DEST_TYPE_SHIFT |
11.70 + (int) destSlot << CONV_VMINFO_SHIFT
11.71 );
11.72 }
11.73 private static long makeConv(int convOp) {
11.74 - assert(convOp == OP_RETYPE_ONLY);
11.75 - return (long) convOp << CONV_OP_SHIFT; // stackMove, src, dst, argnum all zero
11.76 + assert(convOp == OP_RETYPE_ONLY || convOp == OP_RETYPE_RAW);
11.77 + return ((long)-1 << 32) | (convOp << CONV_OP_SHIFT); // stackMove, src, dst all zero
11.78 }
11.79 private static int convCode(long conv) {
11.80 return (int)conv;
11.81 @@ -348,16 +372,6 @@
11.82 /** One of OP_RETYPE_ONLY, etc. */
11.83 int conversionOp() { return (conversion & CONV_OP_MASK) >> CONV_OP_SHIFT; }
11.84
11.85 - @Override
11.86 - public String toString() {
11.87 - return addTypeString(this, "Adapted[" + basicToString(nonAdapter((MethodHandle)vmtarget)) + "]");
11.88 - }
11.89 -
11.90 - private static MethodHandle nonAdapter(MethodHandle mh) {
11.91 - return (MethodHandle)
11.92 - MethodHandleNatives.getTarget(mh, ETF_DIRECT_HANDLE);
11.93 - }
11.94 -
11.95 /* Return one plus the position of the first non-trivial difference
11.96 * between the given types. This is not a symmetric operation;
11.97 * we are considering adapting the targetType to adapterType.
11.98 @@ -399,14 +413,14 @@
11.99 //if (false) return 1; // never adaptable!
11.100 return -1; // some significant difference
11.101 }
11.102 - private static int diffParamTypes(MethodType adapterType, int tstart,
11.103 - MethodType targetType, int astart,
11.104 + private static int diffParamTypes(MethodType adapterType, int astart,
11.105 + MethodType targetType, int tstart,
11.106 int nargs, boolean raw) {
11.107 assert(nargs >= 0);
11.108 int res = 0;
11.109 for (int i = 0; i < nargs; i++) {
11.110 - Class<?> src = adapterType.parameterType(tstart+i);
11.111 - Class<?> dest = targetType.parameterType(astart+i);
11.112 + Class<?> src = adapterType.parameterType(astart+i);
11.113 + Class<?> dest = targetType.parameterType(tstart+i);
11.114 if ((!raw
11.115 ? VerifyType.canPassUnchecked(src, dest)
11.116 : VerifyType.canPassRaw(src, dest)
11.117 @@ -422,7 +436,7 @@
11.118
11.119 /** Can a retyping adapter (alone) validly convert the target to newType? */
11.120 public static boolean canRetypeOnly(MethodType newType, MethodType targetType) {
11.121 - return canRetypeOnly(newType, targetType, false);
11.122 + return canRetype(newType, targetType, false);
11.123 }
11.124 /** Can a retyping adapter (alone) convert the target to newType?
11.125 * It is allowed to widen subword types and void to int, to make bitwise
11.126 @@ -430,14 +444,14 @@
11.127 * reference conversions on return. This last feature requires that the
11.128 * caller be trusted, and perform explicit cast conversions on return values.
11.129 */
11.130 - static boolean canRawRetypeOnly(MethodType newType, MethodType targetType) {
11.131 - return canRetypeOnly(newType, targetType, true);
11.132 + public static boolean canRetypeRaw(MethodType newType, MethodType targetType) {
11.133 + return canRetype(newType, targetType, true);
11.134 }
11.135 - static boolean canRetypeOnly(MethodType newType, MethodType targetType, boolean raw) {
11.136 - if (!convOpSupported(OP_RETYPE_ONLY)) return false;
11.137 + static boolean canRetype(MethodType newType, MethodType targetType, boolean raw) {
11.138 + if (!convOpSupported(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY)) return false;
11.139 int diff = diffTypes(newType, targetType, raw);
11.140 // %%% This assert is too strong. Factor diff into VerifyType and reconcile.
11.141 - assert((diff == 0) == VerifyType.isNullConversion(newType, targetType));
11.142 + assert(raw || (diff == 0) == VerifyType.isNullConversion(newType, targetType));
11.143 return diff == 0;
11.144 }
11.145
11.146 @@ -447,19 +461,21 @@
11.147 */
11.148 public static MethodHandle makeRetypeOnly(Access token,
11.149 MethodType newType, MethodHandle target) {
11.150 - return makeRetypeOnly(token, newType, target, false);
11.151 + return makeRetype(token, newType, target, false);
11.152 }
11.153 - public static MethodHandle makeRawRetypeOnly(Access token,
11.154 + public static MethodHandle makeRetypeRaw(Access token,
11.155 MethodType newType, MethodHandle target) {
11.156 - return makeRetypeOnly(token, newType, target, true);
11.157 + return makeRetype(token, newType, target, true);
11.158 }
11.159 - static MethodHandle makeRetypeOnly(Access token,
11.160 + static MethodHandle makeRetype(Access token,
11.161 MethodType newType, MethodHandle target, boolean raw) {
11.162 Access.check(token);
11.163 - if (!canRetypeOnly(newType, target.type(), raw))
11.164 + MethodType oldType = target.type();
11.165 + if (oldType == newType) return target;
11.166 + if (!canRetype(newType, oldType, raw))
11.167 return null;
11.168 // TO DO: clone the target guy, whatever he is, with new type.
11.169 - return new AdapterMethodHandle(target, newType, makeConv(OP_RETYPE_ONLY));
11.170 + return new AdapterMethodHandle(target, newType, makeConv(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY));
11.171 }
11.172
11.173 /** Can a checkcast adapter validly convert the target to newType?
11.174 @@ -492,7 +508,7 @@
11.175 Access.check(token);
11.176 if (!canCheckCast(newType, target.type(), arg, castType))
11.177 return null;
11.178 - long conv = makeConv(OP_CHECK_CAST, arg, 0);
11.179 + long conv = makeConv(OP_CHECK_CAST, arg, T_OBJECT, T_OBJECT);
11.180 return new AdapterMethodHandle(target, newType, conv, castType);
11.181 }
11.182
11.183 @@ -537,10 +553,9 @@
11.184 int arg, Class<?> convType) {
11.185 Access.check(token);
11.186 MethodType oldType = target.type();
11.187 - Class<?> src = newType.parameterType(arg);
11.188 - Class<?> dst = oldType.parameterType(arg);
11.189 if (!canPrimCast(newType, oldType, arg, convType))
11.190 return null;
11.191 + Class<?> src = newType.parameterType(arg);
11.192 long conv = makeConv(OP_PRIM_TO_PRIM, arg, basicType(src), basicType(convType));
11.193 return new AdapterMethodHandle(target, newType, conv);
11.194 }
11.195 @@ -607,8 +622,6 @@
11.196 return null;
11.197 }
11.198
11.199 - // TO DO: makeSwapArguments, makeRotateArguments, makeDuplicateArguments
11.200 -
11.201 /** Can an adapter simply drop arguments to convert the target to newType? */
11.202 public static boolean canDropArguments(MethodType newType, MethodType targetType,
11.203 int dropArgPos, int dropArgCount) {
11.204 @@ -643,26 +656,195 @@
11.205 Access.check(token);
11.206 if (dropArgCount == 0)
11.207 return makeRetypeOnly(IMPL_TOKEN, newType, target);
11.208 - MethodType mt = target.type();
11.209 - int argCount = mt.parameterCount();
11.210 - if (!canDropArguments(newType, mt, dropArgPos, dropArgCount))
11.211 + if (!canDropArguments(newType, target.type(), dropArgPos, dropArgCount))
11.212 return null;
11.213 - int dropSlotCount, dropSlotPos;
11.214 - if (dropArgCount >= argCount) {
11.215 - assert(dropArgPos == argCount-1);
11.216 - dropSlotPos = 0;
11.217 - dropSlotCount = mt.parameterSlotCount();
11.218 + // in arglist: [0: ...keep1 | dpos: drop... | dpos+dcount: keep2... ]
11.219 + // out arglist: [0: ...keep1 | dpos: keep2... ]
11.220 + int keep2InPos = dropArgPos + dropArgCount;
11.221 + int dropSlot = newType.parameterSlotDepth(keep2InPos);
11.222 + int keep1InSlot = newType.parameterSlotDepth(dropArgPos);
11.223 + int slotCount = keep1InSlot - dropSlot;
11.224 + assert(slotCount >= dropArgCount);
11.225 + assert(target.type().parameterSlotCount() + slotCount == newType.parameterSlotCount());
11.226 + long conv = makeConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount);
11.227 + return new AdapterMethodHandle(target, newType, conv);
11.228 + }
11.229 +
11.230 + /** Can an adapter duplicate an argument to convert the target to newType? */
11.231 + public static boolean canDupArguments(MethodType newType, MethodType targetType,
11.232 + int dupArgPos, int dupArgCount) {
11.233 + if (!convOpSupported(OP_DUP_ARGS)) return false;
11.234 + if (diffReturnTypes(newType, targetType, false) != 0)
11.235 + return false;
11.236 + int nptypes = newType.parameterCount();
11.237 + if (dupArgCount < 0 || dupArgPos + dupArgCount > nptypes)
11.238 + return false;
11.239 + if (targetType.parameterCount() != nptypes + dupArgCount)
11.240 + return false;
11.241 + // parameter types must be the same up to the duplicated arguments
11.242 + if (diffParamTypes(newType, 0, targetType, 0, nptypes, false) != 0)
11.243 + return false;
11.244 + // duplicated types must be, well, duplicates
11.245 + if (diffParamTypes(newType, dupArgPos, targetType, nptypes, dupArgCount, false) != 0)
11.246 + return false;
11.247 + return true;
11.248 + }
11.249 +
11.250 + /** Factory method: Duplicate the selected argument.
11.251 + * Return null if this is not possible.
11.252 + */
11.253 + public static MethodHandle makeDupArguments(Access token,
11.254 + MethodType newType, MethodHandle target,
11.255 + int dupArgPos, int dupArgCount) {
11.256 + Access.check(token);
11.257 + if (!canDupArguments(newType, target.type(), dupArgPos, dupArgCount))
11.258 + return null;
11.259 + if (dupArgCount == 0)
11.260 + return target;
11.261 + // in arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... ]
11.262 + // out arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... | dup... ]
11.263 + int keep2InPos = dupArgPos + dupArgCount;
11.264 + int dupSlot = newType.parameterSlotDepth(keep2InPos);
11.265 + int keep1InSlot = newType.parameterSlotDepth(dupArgPos);
11.266 + int slotCount = keep1InSlot - dupSlot;
11.267 + assert(target.type().parameterSlotCount() - slotCount == newType.parameterSlotCount());
11.268 + long conv = makeConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount);
11.269 + return new AdapterMethodHandle(target, newType, conv);
11.270 + }
11.271 +
11.272 + /** Can an adapter swap two arguments to convert the target to newType? */
11.273 + public static boolean canSwapArguments(MethodType newType, MethodType targetType,
11.274 + int swapArg1, int swapArg2) {
11.275 + if (!convOpSupported(OP_SWAP_ARGS)) return false;
11.276 + if (diffReturnTypes(newType, targetType, false) != 0)
11.277 + return false;
11.278 + if (swapArg1 >= swapArg2) return false; // caller resp
11.279 + int nptypes = newType.parameterCount();
11.280 + if (targetType.parameterCount() != nptypes)
11.281 + return false;
11.282 + if (swapArg1 < 0 || swapArg2 >= nptypes)
11.283 + return false;
11.284 + if (diffParamTypes(newType, 0, targetType, 0, swapArg1, false) != 0)
11.285 + return false;
11.286 + if (diffParamTypes(newType, swapArg1, targetType, swapArg2, 1, false) != 0)
11.287 + return false;
11.288 + if (diffParamTypes(newType, swapArg1+1, targetType, swapArg1+1, swapArg2-swapArg1-1, false) != 0)
11.289 + return false;
11.290 + if (diffParamTypes(newType, swapArg2, targetType, swapArg1, 1, false) != 0)
11.291 + return false;
11.292 + if (diffParamTypes(newType, swapArg2+1, targetType, swapArg2+1, nptypes-swapArg2-1, false) != 0)
11.293 + return false;
11.294 + return true;
11.295 + }
11.296 +
11.297 + /** Factory method: Swap the selected arguments.
11.298 + * Return null if this is not possible.
11.299 + */
11.300 + public static MethodHandle makeSwapArguments(Access token,
11.301 + MethodType newType, MethodHandle target,
11.302 + int swapArg1, int swapArg2) {
11.303 + Access.check(token);
11.304 + if (swapArg1 == swapArg2)
11.305 + return target;
11.306 + if (swapArg1 > swapArg2) { int t = swapArg1; swapArg1 = swapArg2; swapArg2 = t; }
11.307 + if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2))
11.308 + return null;
11.309 + Class<?> swapType = newType.parameterType(swapArg1);
11.310 + // in arglist: [0: ...keep1 | pos1: a1 | pos1+1: keep2... | pos2: a2 | pos2+1: keep3... ]
11.311 + // out arglist: [0: ...keep1 | pos1: a2 | pos1+1: keep2... | pos2: a1 | pos2+1: keep3... ]
11.312 + int swapSlot2 = newType.parameterSlotDepth(swapArg2 + 1);
11.313 + long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(swapType), swapSlot2);
11.314 + return new AdapterMethodHandle(target, newType, conv);
11.315 + }
11.316 +
11.317 + static int positiveRotation(int argCount, int rotateBy) {
11.318 + assert(argCount > 0);
11.319 + if (rotateBy >= 0) {
11.320 + if (rotateBy < argCount)
11.321 + return rotateBy;
11.322 + return rotateBy % argCount;
11.323 + } else if (rotateBy >= -argCount) {
11.324 + return rotateBy + argCount;
11.325 } else {
11.326 - // arglist: [0: keep... | dpos: drop... | dpos+dcount: keep... ]
11.327 - int lastDroppedArg = dropArgPos + dropArgCount - 1;
11.328 - int lastKeptArg = dropArgPos - 1; // might be -1, which is OK
11.329 - dropSlotPos = mt.parameterSlotDepth(1+lastDroppedArg);
11.330 - int lastKeptSlot = mt.parameterSlotDepth(1+lastKeptArg);
11.331 - dropSlotCount = lastKeptSlot - dropSlotPos;
11.332 - assert(dropSlotCount >= dropArgCount);
11.333 + return (-1-((-1-rotateBy) % argCount)) + argCount;
11.334 }
11.335 - long conv = makeConv(OP_DROP_ARGS, dropArgPos, +dropSlotCount);
11.336 - return new AdapterMethodHandle(target, newType, dropSlotCount, conv);
11.337 + }
11.338 +
11.339 + final static int MAX_ARG_ROTATION = 1;
11.340 +
11.341 + /** Can an adapter rotate arguments to convert the target to newType? */
11.342 + public static boolean canRotateArguments(MethodType newType, MethodType targetType,
11.343 + int firstArg, int argCount, int rotateBy) {
11.344 + if (!convOpSupported(OP_ROT_ARGS)) return false;
11.345 + if (argCount <= 2) return false; // must be a swap, not a rotate
11.346 + rotateBy = positiveRotation(argCount, rotateBy);
11.347 + if (rotateBy == 0) return false; // no rotation
11.348 + if (rotateBy > MAX_ARG_ROTATION && rotateBy < argCount - MAX_ARG_ROTATION)
11.349 + return false; // too many argument positions
11.350 + // Rotate incoming args right N to the out args, N in 1..(argCouunt-1).
11.351 + if (diffReturnTypes(newType, targetType, false) != 0)
11.352 + return false;
11.353 + int nptypes = newType.parameterCount();
11.354 + if (targetType.parameterCount() != nptypes)
11.355 + return false;
11.356 + if (firstArg < 0 || firstArg >= nptypes) return false;
11.357 + int argLimit = firstArg + argCount;
11.358 + if (argLimit > nptypes) return false;
11.359 + if (diffParamTypes(newType, 0, targetType, 0, firstArg, false) != 0)
11.360 + return false;
11.361 + int newChunk1 = argCount - rotateBy, newChunk2 = rotateBy;
11.362 + // swap new chunk1 with target chunk2
11.363 + if (diffParamTypes(newType, firstArg, targetType, argLimit-newChunk1, newChunk1, false) != 0)
11.364 + return false;
11.365 + // swap new chunk2 with target chunk1
11.366 + if (diffParamTypes(newType, firstArg+newChunk1, targetType, firstArg, newChunk2, false) != 0)
11.367 + return false;
11.368 + return true;
11.369 + }
11.370 +
11.371 + /** Factory method: Rotate the selected argument range.
11.372 + * Return null if this is not possible.
11.373 + */
11.374 + public static MethodHandle makeRotateArguments(Access token,
11.375 + MethodType newType, MethodHandle target,
11.376 + int firstArg, int argCount, int rotateBy) {
11.377 + Access.check(token);
11.378 + rotateBy = positiveRotation(argCount, rotateBy);
11.379 + if (!canRotateArguments(newType, target.type(), firstArg, argCount, rotateBy))
11.380 + return null;
11.381 + // Decide whether it should be done as a right or left rotation,
11.382 + // on the JVM stack. Return the number of stack slots to rotate by,
11.383 + // positive if right, negative if left.
11.384 + int limit = firstArg + argCount;
11.385 + int depth0 = newType.parameterSlotDepth(firstArg);
11.386 + int depth1 = newType.parameterSlotDepth(limit-rotateBy);
11.387 + int depth2 = newType.parameterSlotDepth(limit);
11.388 + int chunk1Slots = depth0 - depth1; assert(chunk1Slots > 0);
11.389 + int chunk2Slots = depth1 - depth2; assert(chunk2Slots > 0);
11.390 + // From here on out, it assumes a single-argument shift.
11.391 + assert(MAX_ARG_ROTATION == 1);
11.392 + int srcArg, dstArg;
11.393 + byte basicType;
11.394 + if (chunk2Slots <= chunk1Slots) {
11.395 + // Rotate right/down N (rotateBy = +N, N small, c2 small):
11.396 + // in arglist: [0: ...keep1 | arg1: c1... | limit-N: c2 | limit: keep2... ]
11.397 + // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ]
11.398 + srcArg = limit-1;
11.399 + dstArg = firstArg;
11.400 + basicType = basicType(newType.parameterType(srcArg));
11.401 + assert(chunk2Slots == type2size(basicType));
11.402 + } else {
11.403 + // Rotate left/up N (rotateBy = -N, N small, c1 small):
11.404 + // in arglist: [0: ...keep1 | arg1: c1 | arg1+N: c2... | limit: keep2... ]
11.405 + // out arglist: [0: ...keep1 | arg1: c2 ... | limit-N: c1 | limit: keep2... ]
11.406 + srcArg = firstArg;
11.407 + dstArg = limit-1;
11.408 + basicType = basicType(newType.parameterType(srcArg));
11.409 + assert(chunk1Slots == type2size(basicType));
11.410 + }
11.411 + int dstSlot = newType.parameterSlotDepth(dstArg + 1);
11.412 + long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot);
11.413 + return new AdapterMethodHandle(target, newType, conv);
11.414 }
11.415
11.416 /** Can an adapter spread an argument to convert the target to newType? */
11.417 @@ -676,10 +858,10 @@
11.418 if (spreadArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, spreadArgPos, false) != 0)
11.419 return false;
11.420 int afterPos = spreadArgPos + spreadArgCount;
11.421 - int afterCount = nptypes - afterPos;
11.422 + int afterCount = nptypes - (spreadArgPos + 1);
11.423 if (spreadArgPos < 0 || spreadArgPos >= nptypes ||
11.424 spreadArgCount < 0 ||
11.425 - targetType.parameterCount() != nptypes - 1 + spreadArgCount)
11.426 + targetType.parameterCount() != afterPos + afterCount)
11.427 return false;
11.428 // parameter types after the spread point must also be the same
11.429 if (afterCount != 0 && diffParamTypes(newType, spreadArgPos+1, targetType, afterPos, afterCount, false) != 0)
11.430 @@ -697,32 +879,40 @@
11.431 return true;
11.432 }
11.433
11.434 +
11.435 /** Factory method: Spread selected argument. */
11.436 public static MethodHandle makeSpreadArguments(Access token,
11.437 MethodType newType, MethodHandle target,
11.438 Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
11.439 Access.check(token);
11.440 - MethodType mt = target.type();
11.441 - int argCount = mt.parameterCount();
11.442 - if (!canSpreadArguments(newType, mt, spreadArgType, spreadArgPos, spreadArgCount))
11.443 + MethodType targetType = target.type();
11.444 + if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount))
11.445 return null;
11.446 - int spreadSlotCount, spreadSlotPos;
11.447 - if (spreadArgCount >= argCount) {
11.448 - assert(spreadArgPos == argCount-1);
11.449 - spreadSlotPos = 0;
11.450 - spreadSlotCount = mt.parameterSlotCount();
11.451 - } else {
11.452 - // arglist: [0: keep... | dpos: spread... | dpos+dcount: keep... ]
11.453 - int lastSpreadArg = spreadArgPos + spreadArgCount - 1;
11.454 - int lastKeptArg = spreadArgPos - 1; // might be -1, which is OK
11.455 - spreadSlotPos = mt.parameterSlotDepth(1+lastSpreadArg);
11.456 - int lastKeptSlot = mt.parameterSlotDepth(1+lastKeptArg);
11.457 - spreadSlotCount = lastKeptSlot - spreadSlotPos;
11.458 - assert(spreadSlotCount >= spreadArgCount);
11.459 - }
11.460 - long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, spreadSlotCount);
11.461 - return new AdapterMethodHandle(target, newType, conv, spreadArgType);
11.462 + // in arglist: [0: ...keep1 | spos: spreadArg | spos+1: keep2... ]
11.463 + // out arglist: [0: ...keep1 | spos: spread... | spos+scount: keep2... ]
11.464 + int keep2OutPos = spreadArgPos + spreadArgCount;
11.465 + int spreadSlot = targetType.parameterSlotDepth(keep2OutPos);
11.466 + int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos);
11.467 + int slotCount = keep1OutSlot - spreadSlot;
11.468 + assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+1));
11.469 + assert(slotCount >= spreadArgCount);
11.470 + long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, slotCount-1);
11.471 + MethodHandle res = new AdapterMethodHandle(target, newType, conv, spreadArgType);
11.472 + assert(res.type().parameterType(spreadArgPos) == spreadArgType);
11.473 + return res;
11.474 }
11.475
11.476 // TO DO: makeCollectArguments, makeFlyby, makeRicochet
11.477 +
11.478 + @Override
11.479 + public String toString() {
11.480 + return nonAdapter((MethodHandle)vmtarget).toString();
11.481 + }
11.482 +
11.483 + private static MethodHandle nonAdapter(MethodHandle mh) {
11.484 + while (mh instanceof AdapterMethodHandle) {
11.485 + mh = (MethodHandle) mh.vmtarget;
11.486 + }
11.487 + return mh;
11.488 + }
11.489 }
12.1 --- a/src/share/classes/sun/dyn/BoundMethodHandle.java Tue Jan 05 10:40:44 2010 +0800
12.2 +++ b/src/share/classes/sun/dyn/BoundMethodHandle.java Wed Jan 13 15:16:06 2010 -0800
12.3 @@ -28,6 +28,10 @@
12.4 import sun.dyn.util.VerifyType;
12.5 import sun.dyn.util.Wrapper;
12.6 import java.dyn.*;
12.7 +import java.util.List;
12.8 +import sun.dyn.MethodHandleNatives.Constants;
12.9 +import static sun.dyn.MethodHandleImpl.IMPL_LOOKUP;
12.10 +import static sun.dyn.MemberName.newIllegalArgumentException;
12.11
12.12 /**
12.13 * The flavor of method handle which emulates an invoke instruction
12.14 @@ -35,18 +39,23 @@
12.15 * when the handle is created, not when it is invoked.
12.16 * @author jrose
12.17 */
12.18 -public class BoundMethodHandle extends MethodHandle {
12.19 +public class BoundMethodHandle extends MethodHandle {
12.20 //MethodHandle vmtarget; // next BMH or final DMH or methodOop
12.21 private final Object argument; // argument to insert
12.22 private final int vmargslot; // position at which it is inserted
12.23
12.24 + private static final Access IMPL_TOKEN = Access.getToken();
12.25 + private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory(IMPL_TOKEN);
12.26 +
12.27 // Constructors in this class *must* be package scoped or private.
12.28 + // Exception: JavaMethodHandle constructors are protected.
12.29 + // (The link between JMH and BMH is temporary.)
12.30
12.31 /** Bind a direct MH to its receiver (or first ref. argument).
12.32 * The JVM will pre-dispatch the MH if it is not already static.
12.33 */
12.34 BoundMethodHandle(DirectMethodHandle mh, Object argument) {
12.35 - super(Access.TOKEN, mh.type().dropParameterType(0));
12.36 + super(Access.TOKEN, mh.type().dropParameterTypes(0, 1));
12.37 // check the type now, once for all:
12.38 this.argument = checkReferenceArgument(argument, mh, 0);
12.39 this.vmargslot = this.type().parameterSlotCount();
12.40 @@ -56,32 +65,34 @@
12.41 } else {
12.42 this.vmtarget = mh;
12.43 }
12.44 - }
12.45 -
12.46 - private static final int REF_ARG = 0, PRIM_ARG = 1, SELF_ARG = 2;
12.47 + }
12.48
12.49 /** Insert an argument into an arbitrary method handle.
12.50 * If argnum is zero, inserts the first argument, etc.
12.51 * The argument type must be a reference.
12.52 */
12.53 BoundMethodHandle(MethodHandle mh, Object argument, int argnum) {
12.54 - this(mh, argument, argnum, mh.type().parameterType(argnum).isPrimitive() ? PRIM_ARG : REF_ARG);
12.55 + this(mh.type().dropParameterTypes(argnum, argnum+1),
12.56 + mh, argument, argnum);
12.57 }
12.58
12.59 /** Insert an argument into an arbitrary method handle.
12.60 * If argnum is zero, inserts the first argument, etc.
12.61 */
12.62 - BoundMethodHandle(MethodHandle mh, Object argument, int argnum, int whichArg) {
12.63 - super(Access.TOKEN, mh.type().dropParameterType(argnum));
12.64 - if (whichArg == PRIM_ARG)
12.65 + BoundMethodHandle(MethodType type, MethodHandle mh, Object argument, int argnum) {
12.66 + super(Access.TOKEN, type);
12.67 + if (mh.type().parameterType(argnum).isPrimitive())
12.68 this.argument = bindPrimitiveArgument(argument, mh, argnum);
12.69 else {
12.70 - if (whichArg == SELF_ARG) argument = this;
12.71 this.argument = checkReferenceArgument(argument, mh, argnum);
12.72 }
12.73 - this.vmargslot = this.type().parameterSlotDepth(argnum);
12.74 + this.vmargslot = type.parameterSlotDepth(argnum);
12.75 + initTarget(mh, argnum);
12.76 + }
12.77 +
12.78 + private void initTarget(MethodHandle mh, int argnum) {
12.79 if (MethodHandleNatives.JVM_SUPPORT) {
12.80 - this.vmtarget = null; // maybe updated by JVM
12.81 + this.vmtarget = null; // maybe updated by JVM
12.82 MethodHandleNatives.init(this, mh, argnum);
12.83 } else {
12.84 this.vmtarget = mh;
12.85 @@ -97,29 +108,65 @@
12.86 assert(this.getClass() == AdapterMethodHandle.class);
12.87 }
12.88
12.89 - /** Initialize the current object as a method handle, binding it
12.90 - * as the {@code argnum}th argument of the method handle {@code entryPoint}.
12.91 - * The invocation type of the resulting method handle will be the
12.92 - * same as {@code entryPoint}, except that the {@code argnum}th argument
12.93 - * type will be dropped.
12.94 - */
12.95 - public BoundMethodHandle(MethodHandle entryPoint, int argnum) {
12.96 - this(entryPoint, null, argnum, SELF_ARG);
12.97 -
12.98 - // Note: If the conversion fails, perhaps because of a bad entryPoint,
12.99 - // the MethodHandle.type field will not be filled in, and therefore
12.100 - // no MH.invoke call will ever succeed. The caller may retain a pointer
12.101 - // to the broken method handle, but no harm can be done with it.
12.102 - }
12.103 -
12.104 - /** Initialize the current object as a method handle, binding it
12.105 + /** Initialize the current object as a Java method handle, binding it
12.106 * as the first argument of the method handle {@code entryPoint}.
12.107 * The invocation type of the resulting method handle will be the
12.108 * same as {@code entryPoint}, except that the first argument
12.109 * type will be dropped.
12.110 */
12.111 - public BoundMethodHandle(MethodHandle entryPoint) {
12.112 - this(entryPoint, null, 0, SELF_ARG);
12.113 + protected BoundMethodHandle(MethodHandle entryPoint) {
12.114 + super(Access.TOKEN, entryPoint.type().dropParameterTypes(0, 1));
12.115 + this.argument = this; // kludge; get rid of
12.116 + this.vmargslot = this.type().parameterSlotDepth(0);
12.117 + initTarget(entryPoint, 0);
12.118 + assert(this instanceof JavaMethodHandle);
12.119 + }
12.120 +
12.121 + /** Initialize the current object as a Java method handle.
12.122 + */
12.123 + protected BoundMethodHandle(String entryPointName, MethodType type, boolean matchArity) {
12.124 + super(Access.TOKEN, null);
12.125 + MethodHandle entryPoint
12.126 + = findJavaMethodHandleEntryPoint(this.getClass(),
12.127 + entryPointName, type, matchArity);
12.128 + MethodHandleImpl.initType(this, entryPoint.type().dropParameterTypes(0, 1));
12.129 + this.argument = this; // kludge; get rid of
12.130 + this.vmargslot = this.type().parameterSlotDepth(0);
12.131 + initTarget(entryPoint, 0);
12.132 + assert(this instanceof JavaMethodHandle);
12.133 + }
12.134 +
12.135 + private static
12.136 + MethodHandle findJavaMethodHandleEntryPoint(Class<?> caller,
12.137 + String name,
12.138 + MethodType type,
12.139 + boolean matchArity) {
12.140 + if (matchArity) type.getClass(); // elicit NPE
12.141 + List<MemberName> methods = IMPL_NAMES.getMethods(caller, true, name, null, caller);
12.142 + MethodType foundType = null;
12.143 + MemberName foundMethod = null;
12.144 + for (MemberName method : methods) {
12.145 + MethodType mtype = method.getMethodType();
12.146 + if (type != null && type.parameterCount() != mtype.parameterCount())
12.147 + continue;
12.148 + else if (foundType == null)
12.149 + foundType = mtype;
12.150 + else if (foundType != mtype)
12.151 + throw newIllegalArgumentException("more than one method named "+name+" in "+caller.getName());
12.152 + // discard overrides
12.153 + if (foundMethod == null)
12.154 + foundMethod = method;
12.155 + else if (foundMethod.getDeclaringClass().isAssignableFrom(method.getDeclaringClass()))
12.156 + foundMethod = method;
12.157 + }
12.158 + if (foundMethod == null)
12.159 + throw newIllegalArgumentException("no method named "+name+" in "+caller.getName());
12.160 + MethodHandle entryPoint = MethodHandleImpl.findMethod(IMPL_TOKEN, foundMethod, true, caller);
12.161 + if (type != null) {
12.162 + MethodType epType = type.insertParameterTypes(0, entryPoint.type().parameterType(0));
12.163 + entryPoint = MethodHandles.convertArguments(entryPoint, epType);
12.164 + }
12.165 + return entryPoint;
12.166 }
12.167
12.168 /** Make sure the given {@code argument} can be used as {@code argnum}-th
12.169 @@ -175,6 +222,24 @@
12.170
12.171 @Override
12.172 public String toString() {
12.173 - return "Bound[" + super.toString() + "]";
12.174 + MethodHandle mh = this;
12.175 + while (mh instanceof BoundMethodHandle) {
12.176 + Object info = MethodHandleNatives.getTargetInfo(mh);
12.177 + if (info instanceof MethodHandle) {
12.178 + mh = (MethodHandle) info;
12.179 + } else {
12.180 + String name = null;
12.181 + if (info instanceof MemberName)
12.182 + name = ((MemberName)info).getName();
12.183 + if (name != null)
12.184 + return name;
12.185 + else
12.186 + return super.toString(); // <unknown>, probably
12.187 + }
12.188 + assert(mh != this);
12.189 + if (mh instanceof JavaMethodHandle)
12.190 + break; // access JMH.toString(), not BMH.toString()
12.191 + }
12.192 + return mh.toString();
12.193 }
12.194 }
13.1 --- a/src/share/classes/sun/dyn/CallSiteImpl.java Tue Jan 05 10:40:44 2010 +0800
13.2 +++ b/src/share/classes/sun/dyn/CallSiteImpl.java Wed Jan 13 15:16:06 2010 -0800
13.3 @@ -26,34 +26,51 @@
13.4 package sun.dyn;
13.5
13.6 import java.dyn.*;
13.7 +import java.util.logging.Level;
13.8 +import java.util.logging.Logger;
13.9
13.10 /**
13.11 - * The CallSite privately created by the JVM at every invokedynamic instruction.
13.12 + * Parts of CallSite known to the JVM.
13.13 + * FIXME: Merge all this into CallSite proper.
13.14 * @author jrose
13.15 */
13.16 -class CallSiteImpl extends CallSite {
13.17 - // Fields used only by the JVM. Do not use or change.
13.18 +public class CallSiteImpl {
13.19 + // Field used only by the JVM. Do not use or change.
13.20 private Object vmmethod;
13.21
13.22 // Values supplied by the JVM:
13.23 - int callerMID, callerBCI;
13.24 + protected int callerMID, callerBCI;
13.25
13.26 - private CallSiteImpl(Class<?> caller, String name, MethodType type) {
13.27 - super(caller, name, type);
13.28 + private MethodHandle target;
13.29 + protected final Object caller; // usually a class
13.30 + protected final String name;
13.31 + protected final MethodType type;
13.32 +
13.33 + /** called only directly from CallSite() */
13.34 + protected CallSiteImpl(Access token, Object caller, String name, MethodType type) {
13.35 + Access.check(token);
13.36 + this.caller = caller;
13.37 + this.name = name;
13.38 + this.type = type;
13.39 }
13.40
13.41 - @Override
13.42 - public void setTarget(MethodHandle mh) {
13.43 - checkTarget(mh);
13.44 - if (MethodHandleNatives.JVM_SUPPORT)
13.45 - MethodHandleNatives.linkCallSite(this, (MethodHandle) mh);
13.46 - else
13.47 - super.setTarget(mh);
13.48 + /** native version of setTarget */
13.49 + protected void setTarget(MethodHandle mh) {
13.50 + //System.out.println("setTarget "+this+" := "+mh);
13.51 + // XXX I don't know how to fix this properly.
13.52 +// if (false && MethodHandleNatives.JVM_SUPPORT) // FIXME: enable this
13.53 +// MethodHandleNatives.linkCallSite(this, mh);
13.54 +// else
13.55 + this.target = mh;
13.56 + }
13.57 +
13.58 + protected MethodHandle getTarget() {
13.59 + return target;
13.60 }
13.61
13.62 private static final MethodHandle PRIVATE_INITIALIZE_CALL_SITE =
13.63 MethodHandleImpl.IMPL_LOOKUP.findStatic(CallSite.class, "privateInitializeCallSite",
13.64 - MethodType.make(void.class, CallSite.class, int.class, int.class));
13.65 + MethodType.methodType(void.class, CallSite.class, int.class, int.class));
13.66
13.67 // this is the up-call from the JVM:
13.68 static CallSite makeSite(Class<?> caller, String name, MethodType type,
13.69 @@ -61,10 +78,25 @@
13.70 MethodHandle bsm = Linkage.getBootstrapMethod(caller);
13.71 if (bsm == null)
13.72 throw new InvokeDynamicBootstrapError("class has no bootstrap method: "+caller);
13.73 - CallSite site = bsm.<CallSite>invoke(caller, name, type);
13.74 + CallSite site;
13.75 + try {
13.76 + site = bsm.<CallSite>invoke(caller, name, type);
13.77 + } catch (Throwable ex) {
13.78 + throw new InvokeDynamicBootstrapError("exception thrown while linking", ex);
13.79 + }
13.80 if (site == null)
13.81 throw new InvokeDynamicBootstrapError("class bootstrap method failed to create a call site: "+caller);
13.82 - PRIVATE_INITIALIZE_CALL_SITE.<void>invoke(site, callerMID, callerBCI);
13.83 + if (site.type() != type)
13.84 + throw new InvokeDynamicBootstrapError("call site type not initialized correctly: "+site);
13.85 + if (site.callerClass() != caller)
13.86 + throw new InvokeDynamicBootstrapError("call site caller not initialized correctly: "+site);
13.87 + if ((Object)site.name() != name)
13.88 + throw new InvokeDynamicBootstrapError("call site name not initialized correctly: "+site);
13.89 + try {
13.90 + PRIVATE_INITIALIZE_CALL_SITE.<void>invoke(site, callerMID, callerBCI);
13.91 + } catch (Throwable ex) {
13.92 + throw new InvokeDynamicBootstrapError("call site initialization exception", ex);
13.93 + }
13.94 return site;
13.95 }
13.96 }
14.1 --- a/src/share/classes/sun/dyn/FilterGeneric.java Tue Jan 05 10:40:44 2010 +0800
14.2 +++ b/src/share/classes/sun/dyn/FilterGeneric.java Wed Jan 13 15:16:06 2010 -0800
14.3 @@ -31,174 +31,159 @@
14.4 import java.dyn.NoAccessException;
14.5 import java.lang.reflect.Constructor;
14.6 import java.lang.reflect.InvocationTargetException;
14.7 +import static sun.dyn.MemberName.newIllegalArgumentException;
14.8
14.9 /**
14.10 - * "Flyby adapters" which apply arbitrary conversions to arguments
14.11 + * These adapters apply arbitrary conversions to arguments
14.12 * on the way to a ultimate target.
14.13 * For simplicity, these are all generically typed.
14.14 * @author jrose
14.15 */
14.16 class FilterGeneric {
14.17 - // type for the outgoing call (will be generic)
14.18 - private final MethodType targetType;
14.19 - // position of (first) argument to participate in filtering
14.20 - private final short argumentPosition;
14.21 - // number of arguments to participate in filtering
14.22 - private final short argumentCount;
14.23 - // how the result interacts with the filtered arguments: Prepend, Append, Replace, Discard
14.24 - private final char replaceMode;
14.25 - // prototype adapter (clone and customize for each new target & conversion!)
14.26 - private final Adapter adapter;
14.27 - // entry point for adapter (Adapter mh, a...) => ...
14.28 - private final MethodHandle entryPoint;
14.29 - // more of them (loosely cached)
14.30 - private FilterGeneric variations;
14.31 + // type for the incoming call (will be generic)
14.32 + private final MethodType entryType;
14.33 + // prototype adapters (clone and customize for each new target & conversion!)
14.34 + private final Adapter[] adapters;
14.35
14.36 - /** Compute and cache information common to all unboxing adapters
14.37 - * that can call out to targets of the erasure-family of the given erased type.
14.38 + /** Compute and cache information common to all filtering adapters
14.39 + * with the given generic type
14.40 */
14.41 - // TO DO: Make this private.
14.42 - FilterGeneric(MethodType targetType, short argumentPosition, short argumentCount, char replaceMode) {
14.43 - if (argumentCount == 0) {
14.44 - if (replaceMode == 'P' || replaceMode == 'A') replaceMode = 'R';
14.45 - if (replaceMode == 'I') argumentPosition = 0;
14.46 - }
14.47 - this.targetType = targetType;
14.48 - this.argumentPosition = argumentPosition;
14.49 - this.argumentCount = argumentCount;
14.50 - this.replaceMode = replaceMode;
14.51 - validate(targetType, argumentPosition, argumentCount, replaceMode);
14.52 - Adapter ad = findAdapter(targetType, argumentPosition, argumentCount, replaceMode, filterType());
14.53 - if (ad == null)
14.54 - ad = buildAdapterFromBytecodes(targetType, argumentPosition, argumentCount, replaceMode, filterType());
14.55 - this.adapter = ad;
14.56 - this.entryPoint = ad.prototypeEntryPoint();
14.57 + FilterGeneric(MethodType entryType) {
14.58 + this.entryType = entryType;
14.59 + int tableSize = Kind.LIMIT.invokerIndex(1 + entryType.parameterCount());
14.60 + this.adapters = new Adapter[tableSize];
14.61 }
14.62
14.63 - Adapter makeInstance(MethodHandle filter, MethodHandle target) {
14.64 - return adapter.makeInstance(entryPoint, filter, target);
14.65 + Adapter getAdapter(Kind kind, int pos) {
14.66 + int index = kind.invokerIndex(pos);
14.67 + Adapter ad = adapters[index];
14.68 + if (ad != null) return ad;
14.69 + ad = findAdapter(entryType, kind, pos);
14.70 + if (ad == null)
14.71 + ad = buildAdapterFromBytecodes(entryType, kind, pos);
14.72 + adapters[index] = ad;
14.73 + return ad;
14.74 }
14.75
14.76 - /** Build an adapter of the given generic type, which invokes typedTarget
14.77 - * on the incoming arguments, after unboxing as necessary.
14.78 - * The return value is boxed if necessary.
14.79 - * @param genericType the required type of the result
14.80 - * @param typedTarget the target
14.81 + Adapter makeInstance(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
14.82 + Adapter ad = getAdapter(kind, pos);
14.83 + return ad.makeInstance(ad.prototypeEntryPoint(), filter, target);
14.84 + }
14.85 +
14.86 + /** Build an adapter of the given generic type, which invokes filter
14.87 + * on the selected incoming argument before passing it to the target.
14.88 + * @param pos the argument to filter
14.89 + * @param filter the function to call on the argument
14.90 + * @param target the target to call with the modified argument list
14.91 * @return an adapter method handle
14.92 */
14.93 - public static MethodHandle make(MethodHandle target, int pos, MethodHandle filter) {
14.94 - return FilterGeneric.of(target.type(), (short)pos, (short)1, 'R').makeInstance(filter, target);
14.95 + public static MethodHandle makeArgumentFilter(int pos, MethodHandle filter, MethodHandle target) {
14.96 + return make(Kind.value, pos, filter, target);
14.97 }
14.98
14.99 - /** Return the adapter information for this type's erasure. */
14.100 - static FilterGeneric of(MethodType type, short ap, short ac, char mode) {
14.101 - if (type.generic() != type)
14.102 - throw new IllegalArgumentException("must be generic: "+type);
14.103 - validate(type, ap, ac, mode);
14.104 - MethodTypeImpl form = MethodTypeImpl.of(type);
14.105 + /** Build an adapter of the given generic type, which invokes a combiner
14.106 + * on a selected group of leading arguments.
14.107 + * The result of the combiner is prepended before all those arguments.
14.108 + * @param combiner the function to call on the selected leading arguments
14.109 + * @param target the target to call with the modified argument list
14.110 + * @return an adapter method handle
14.111 + */
14.112 + public static MethodHandle makeArgumentFolder(MethodHandle combiner, MethodHandle target) {
14.113 + int num = combiner.type().parameterCount();
14.114 + return make(Kind.fold, num, combiner, target);
14.115 + }
14.116 +
14.117 + /** Build an adapter of the given generic type, which invokes a filter
14.118 + * on the incoming arguments, reified as a group.
14.119 + * The argument may be modified (by side effects in the filter).
14.120 + * The arguments, possibly modified, are passed on to the target.
14.121 + * @param filter the function to call on the arguments
14.122 + * @param target the target to call with the possibly-modified argument list
14.123 + * @return an adapter method handle
14.124 + */
14.125 + public static MethodHandle makeFlyby(MethodHandle filter, MethodHandle target) {
14.126 + return make(Kind.flyby, 0, filter, target);
14.127 + }
14.128 +
14.129 + /** Build an adapter of the given generic type, which invokes a collector
14.130 + * on the selected incoming argument and all following arguments.
14.131 + * The result of the collector replaces all those arguments.
14.132 + * @param collector the function to call on the selected trailing arguments
14.133 + * @param target the target to call with the modified argument list
14.134 + * @return an adapter method handle
14.135 + */
14.136 + public static MethodHandle makeArgumentCollector(MethodHandle collector, MethodHandle target) {
14.137 + int pos = target.type().parameterCount() - 1;
14.138 + return make(Kind.collect, pos, collector, target);
14.139 + }
14.140 +
14.141 + static MethodHandle make(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
14.142 + FilterGeneric fgen = of(kind, pos, filter.type(), target.type());
14.143 + return fgen.makeInstance(kind, pos, filter, target);
14.144 + }
14.145 +
14.146 + /** Return the adapter information for this target and filter type. */
14.147 + static FilterGeneric of(Kind kind, int pos, MethodType filterType, MethodType targetType) {
14.148 + MethodType entryType = entryType(kind, pos, filterType, targetType);
14.149 + if (entryType.generic() != entryType)
14.150 + throw newIllegalArgumentException("must be generic: "+entryType);
14.151 + MethodTypeImpl form = MethodTypeImpl.of(entryType);
14.152 FilterGeneric filterGen = form.filterGeneric;
14.153 if (filterGen == null)
14.154 - form.filterGeneric = filterGen = new FilterGeneric(type, (short)0, (short)1, 'R');
14.155 - return find(filterGen, ap, ac, mode);
14.156 - }
14.157 -
14.158 - static FilterGeneric find(FilterGeneric gen, short ap, short ac, char mode) {
14.159 - for (;;) {
14.160 - if (gen.argumentPosition == ap &&
14.161 - gen.argumentCount == ac &&
14.162 - gen.replaceMode == mode) {
14.163 - return gen;
14.164 - }
14.165 - FilterGeneric gen2 = gen.variations;
14.166 - if (gen2 == null) break;
14.167 - gen = gen2;
14.168 - }
14.169 - FilterGeneric gen2 = new FilterGeneric(gen.targetType, ap, ac, mode);
14.170 - gen.variations = gen2; // OK if this smashes another cached chain
14.171 - return gen2;
14.172 - }
14.173 -
14.174 - private static void validate(MethodType type, short ap, short ac, char mode) {
14.175 - int endpos = ap + ac;
14.176 - switch (mode) {
14.177 - case 'P': case 'A': case 'R': case 'D':
14.178 - if (ap >= 0 && ac >= 0 &&
14.179 - endpos >= 0 && endpos <= type.parameterCount())
14.180 - return;
14.181 - default:
14.182 - throw new InternalError("configuration "+patternName(ap, ac, mode));
14.183 - }
14.184 + form.filterGeneric = filterGen = new FilterGeneric(entryType);
14.185 + return filterGen;
14.186 }
14.187
14.188 public String toString() {
14.189 - return "FilterGeneric/"+patternName()+targetType;
14.190 + return "FilterGeneric/"+entryType;
14.191 }
14.192
14.193 - String patternName() {
14.194 - return patternName(argumentPosition, argumentCount, replaceMode);
14.195 - }
14.196 -
14.197 - static String patternName(short ap, short ac, char mode) {
14.198 - return ""+mode+ap+(ac>1?"_"+ac:"");
14.199 - }
14.200 -
14.201 - Class<?> filterType() {
14.202 - return Object.class; // result of filter operation; an uninteresting type
14.203 - }
14.204 -
14.205 - static MethodType targetType(MethodType entryType, short ap, short ac, char mode,
14.206 - Class<?> arg) {
14.207 + static MethodType targetType(MethodType entryType, Kind kind, int pos, MethodType filterType) {
14.208 MethodType type = entryType;
14.209 - int pos = ap;
14.210 - switch (mode) {
14.211 - case 'A':
14.212 - pos += ac;
14.213 - case 'P':
14.214 - type = type.insertParameterType(pos, arg);
14.215 + switch (kind) {
14.216 + case value:
14.217 + case flyby:
14.218 + break; // no change
14.219 + case fold:
14.220 + type = type.insertParameterTypes(0, filterType.returnType());
14.221 break;
14.222 - case 'I':
14.223 - for (int i = 1; i < ac; i++)
14.224 - type = type.dropParameterType(pos);
14.225 - assert(type.parameterType(pos) == arg);
14.226 + case collect:
14.227 + type = type.dropParameterTypes(pos, type.parameterCount());
14.228 + type = type.insertParameterTypes(pos, filterType.returnType());
14.229 break;
14.230 - case 'D':
14.231 - break;
14.232 + default:
14.233 + throw new InternalError();
14.234 }
14.235 return type;
14.236 }
14.237
14.238 - static MethodType entryType(MethodType targetType, short ap, short ac, char mode,
14.239 - Class<?> arg) {
14.240 + static MethodType entryType(Kind kind, int pos, MethodType filterType, MethodType targetType) {
14.241 MethodType type = targetType;
14.242 - int pos = ap;
14.243 - switch (mode) {
14.244 - case 'A':
14.245 - pos += ac;
14.246 - case 'P':
14.247 - type = type.dropParameterType(pos);
14.248 + switch (kind) {
14.249 + case value:
14.250 + case flyby:
14.251 + break; // no change
14.252 + case fold:
14.253 + type = type.dropParameterTypes(0, 1);
14.254 break;
14.255 - case 'I':
14.256 - for (int i = 1; i < ac; i++)
14.257 - type = type.insertParameterType(pos, arg);
14.258 - assert(type.parameterType(pos) == arg);
14.259 + case collect:
14.260 + type = type.dropParameterTypes(pos, pos+1);
14.261 + type = type.insertParameterTypes(pos, filterType.parameterList());
14.262 break;
14.263 - case 'D':
14.264 - break;
14.265 + default:
14.266 + throw new InternalError();
14.267 }
14.268 return type;
14.269 }
14.270
14.271 /* Create an adapter that handles spreading calls for the given type. */
14.272 - static Adapter findAdapter(MethodType targetType, short ap, short ac, char mode, Class<?> arg) {
14.273 - MethodType entryType = entryType(targetType, ap, ac, mode, arg);
14.274 - int argc = targetType.parameterCount();
14.275 - String pname = patternName(ap, ac, mode);
14.276 + static Adapter findAdapter(MethodType entryType, Kind kind, int pos) {
14.277 + int argc = entryType.parameterCount();
14.278 String cname0 = "F"+argc;
14.279 - String cname1 = "F"+argc+mode;
14.280 - String cname2 = "F"+argc+pname;
14.281 - String[] cnames = { cname0, cname1, cname1+"X", cname2 };
14.282 - String iname = "invoke_"+pname;
14.283 - // e.g., F5R; invoke_R3
14.284 + String cname1 = "F"+argc+kind.key;
14.285 + String[] cnames = { cname0, cname1 };
14.286 + String iname = kind.invokerName(pos);
14.287 + // e.g., F5; invoke_C3
14.288 for (String cname : cnames) {
14.289 Class<? extends Adapter> acls = Adapter.findSubClass(cname);
14.290 if (acls == null) continue;
14.291 @@ -220,7 +205,10 @@
14.292 // Produce an instance configured as a prototype.
14.293 return ctor.newInstance(entryPoint);
14.294 } catch (IllegalArgumentException ex) {
14.295 - } catch (InvocationTargetException ex) {
14.296 + } catch (InvocationTargetException wex) {
14.297 + Throwable ex = wex.getTargetException();
14.298 + if (ex instanceof Error) throw (Error)ex;
14.299 + if (ex instanceof RuntimeException) throw (RuntimeException)ex;
14.300 } catch (InstantiationException ex) {
14.301 } catch (IllegalAccessException ex) {
14.302 }
14.303 @@ -228,7 +216,7 @@
14.304 return null;
14.305 }
14.306
14.307 - static Adapter buildAdapterFromBytecodes(MethodType targetType, short ap, short ac, char mode, Class<?> arg) {
14.308 + static Adapter buildAdapterFromBytecodes(MethodType entryType, Kind kind, int pos) {
14.309 throw new UnsupportedOperationException("NYI");
14.310 }
14.311
14.312 @@ -242,8 +230,13 @@
14.313 * generated once per type erasure family, and reused across adapters.
14.314 */
14.315 static abstract class Adapter extends JavaMethodHandle {
14.316 - protected final MethodHandle filter;
14.317 - protected final MethodHandle target;
14.318 + protected final MethodHandle filter; // transforms one or more arguments
14.319 + protected final MethodHandle target; // ultimate target
14.320 +
14.321 + @Override
14.322 + public String toString() {
14.323 + return target.toString();
14.324 + }
14.325
14.326 protected boolean isPrototype() { return target == null; }
14.327 protected Adapter(MethodHandle entryPoint) {
14.328 @@ -287,52 +280,4221 @@
14.329 }
14.330 }
14.331
14.332 - //* generated classes follow this pattern:
14.333 - static class F1RX extends Adapter {
14.334 - protected F1RX(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.335 - protected F1RX(MethodHandle e, MethodHandle f, MethodHandle t)
14.336 + static enum Kind {
14.337 + value('V'), // filter and replace Nth argument value
14.338 + fold('F'), // fold first N arguments, prepend result
14.339 + collect('C'), // collect last N arguments, replace with result
14.340 + flyby('Y'), // reify entire argument list, filter, pass to target
14.341 + LIMIT('?');
14.342 + static final int COUNT = LIMIT.ordinal();
14.343 +
14.344 + final char key;
14.345 + Kind(char key) { this.key = key; }
14.346 + String invokerName(int pos) { return "invoke_"+key+""+pos; }
14.347 + int invokerIndex(int pos) { return pos * COUNT + ordinal(); }
14.348 + }
14.349 +
14.350 + /* generated classes follow this pattern:
14.351 + static class F1X extends Adapter {
14.352 + protected F1X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.353 + protected F1X(MethodHandle e, MethodHandle f, MethodHandle t)
14.354 { super(e, f, t); }
14.355 - protected F1RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.356 - { return new F1RX(e, f, t); }
14.357 - protected Object filter(Object a0) { return filter.<Object>invoke(a0); }
14.358 - protected Object target(Object a0) { return target.<Object>invoke(a0); }
14.359 - protected Object invoke_R0(Object a0) { return target(filter(a0)); }
14.360 + protected F1X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.361 + { return new F1X(e, f, t); }
14.362 + protected Object invoke_V0(Object a0) { return target.invoke(filter.invoke(a0)); }
14.363 + protected Object invoke_F0(Object a0) { return target.invoke(filter.invoke(), a0); }
14.364 + protected Object invoke_F1(Object a0) { return target.invoke(filter.invoke(a0), a0); }
14.365 + protected Object invoke_C0(Object a0) { return target.invoke(filter.invoke(a0)); }
14.366 + protected Object invoke_C1(Object a0) { return target.invoke(a0, filter.invoke()); }
14.367 + protected Object invoke_Y0(Object a0) { Object[] av = { a0 };
14.368 + filter.<void>invoke(av); return target.invoke(av[0]); }
14.369 }
14.370 - static class F2RX extends Adapter {
14.371 - protected F2RX(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.372 - protected F2RX(MethodHandle e, MethodHandle f, MethodHandle t)
14.373 + static class F2X extends Adapter {
14.374 + protected F2X(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.375 + protected F2X(MethodHandle e, MethodHandle f, MethodHandle t)
14.376 { super(e, f, t); }
14.377 - protected F2RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.378 - { return new F2RX(e, f, t); }
14.379 - protected Object filter(Object a0) { return filter.<Object>invoke(a0); }
14.380 - protected Object target(Object a0, Object a1) { return target.<Object>invoke(a0, a1); }
14.381 - protected Object invoke_R0(Object a0, Object a1) { return target(filter(a0), a1); }
14.382 - protected Object invoke_R1(Object a0, Object a1) { return target(a0, filter(a1)); }
14.383 - }
14.384 - static class F3RX extends Adapter {
14.385 - protected F3RX(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.386 - protected F3RX(MethodHandle e, MethodHandle f, MethodHandle t)
14.387 - { super(e, f, t); }
14.388 - protected F3RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.389 - { return new F3RX(e, f, t); }
14.390 - protected Object filter(Object a0) { return filter.<Object>invoke(a0); }
14.391 - protected Object target(Object a0, Object a1, Object a2) { return target.<Object>invoke(a0, a1, a2); }
14.392 - protected Object invoke_R0(Object a0, Object a1, Object a2) { return target(filter(a0), a1, a2); }
14.393 - protected Object invoke_R1(Object a0, Object a1, Object a2) { return target(a0, filter(a1), a2); }
14.394 - protected Object invoke_R2(Object a0, Object a1, Object a2) { return target(a0, a1, filter(a2)); }
14.395 - }
14.396 - static class F4RX extends Adapter {
14.397 - protected F4RX(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.398 - protected F4RX(MethodHandle e, MethodHandle f, MethodHandle t)
14.399 - { super(e, f, t); }
14.400 - protected F4RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.401 - { return new F4RX(e, f, t); }
14.402 - protected Object filter(Object a0) { return filter.<Object>invoke(a0); }
14.403 - protected Object target(Object a0, Object a1, Object a2, Object a3) { return target.<Object>invoke(a0, a1, a2, a3); }
14.404 - protected Object invoke_R0(Object a0, Object a1, Object a2, Object a3) { return target(filter(a0), a1, a2, a3); }
14.405 - protected Object invoke_R1(Object a0, Object a1, Object a2, Object a3) { return target(a0, filter(a1), a2, a3); }
14.406 - protected Object invoke_R2(Object a0, Object a1, Object a2, Object a3) { return target(a0, a1, filter(a2), a3); }
14.407 - protected Object invoke_R3(Object a0, Object a1, Object a2, Object a3) { return target(a0, a1, a2, filter(a3)); }
14.408 + protected F2X makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)
14.409 + { return new F2X(e, f, t); }
14.410 + protected Object invoke_V0(Object a0, Object a1) { return target.invoke(filter.invoke(a0), a1); }
14.411 + protected Object invoke_V1(Object a0, Object a1) { return target.invoke(a0, filter.invoke(a1)); }
14.412 + protected Object invoke_F0(Object a0, Object a1) { return target.invoke(filter.invoke(), a0, a1); }
14.413 + protected Object invoke_F1(Object a0, Object a1) { return target.invoke(filter.invoke(a0), a0, a1); }
14.414 + protected Object invoke_F2(Object a0, Object a1) { return target.invoke(filter.invoke(a0, a1), a0, a1); }
14.415 + protected Object invoke_C0(Object a0, Object a1) { return target.invoke(filter.invoke(a0, a1)); }
14.416 + protected Object invoke_C1(Object a0, Object a1) { return target.invoke(a0, filter.invoke(a1)); }
14.417 + protected Object invoke_C2(Object a0, Object a1) { return target.invoke(a0, a1, filter.invoke()); }
14.418 + protected Object invoke_Y0(Object a0, Object a1) { Object[] av = { a0, a1 };
14.419 + filter.<void>invoke(av); return target.invoke(av[0], av[1]); }
14.420 }
14.421 // */
14.422 +
14.423 + // This one is written by hand:
14.424 + static class F0 extends Adapter {
14.425 + protected F0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.426 + protected F0(MethodHandle e, MethodHandle f, MethodHandle t) {
14.427 + super(e, f, t); }
14.428 + protected F0 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.429 + return new F0(e, f, t); }
14.430 + protected Object invoke_F0() throws Throwable {
14.431 + return target.invoke(filter.invoke()); }
14.432 + protected Object invoke_C0() throws Throwable {
14.433 + return target.invoke(filter.invoke()); }
14.434 + static final Object[] NO_ARGS = { };
14.435 + protected Object invoke_Y0() throws Throwable {
14.436 + filter.<void>invoke(NO_ARGS); // make the flyby
14.437 + return target.invoke(); }
14.438 + }
14.439 +
14.440 +/*
14.441 + : 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~
14.442 +//{{{
14.443 +import java.util.*;
14.444 +class genclasses {
14.445 + static String[][] TEMPLATES = { {
14.446 + "@for@ N=1..20",
14.447 + " //@each-cat@",
14.448 + " static class @cat@ extends Adapter {",
14.449 + " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
14.450 + " protected @cat@(MethodHandle e, MethodHandle f, MethodHandle t) {",
14.451 + " super(e, f, t); }",
14.452 + " protected @cat@ makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {",
14.453 + " return new @cat@(e, f, t); }",
14.454 + " //@each-P@",
14.455 + " protected Object invoke_V@P@(@Tvav@) throws Throwable {",
14.456 + " return target.invoke(@a0_@@Psp@filter.invoke(a@P@)@_aN@); }",
14.457 + " //@end-P@",
14.458 + " //@each-P@",
14.459 + " protected Object invoke_F@P@(@Tvav@) throws Throwable {",
14.460 + " return target.invoke(filter.invoke(@a0@),",
14.461 + " @av@); }",
14.462 + " //@end-P@",
14.463 + " protected Object invoke_F@N@(@Tvav@) throws Throwable {",
14.464 + " return target.invoke(filter.invoke(@av@),",
14.465 + " @av@); }",
14.466 + " //@each-P@",
14.467 + " protected Object invoke_C@P@(@Tvav@) throws Throwable {",
14.468 + " return target.invoke(@a0_@filter.invoke(a@P@@_aN@)); }",
14.469 + " //@end-P@",
14.470 + " protected Object invoke_C@N@(@Tvav@) throws Throwable {",
14.471 + " return target.invoke(@av@, filter.invoke()); }",
14.472 + " protected Object invoke_Y0(@Tvav@) throws Throwable {",
14.473 + " Object[] av = { @av@ };",
14.474 + " filter.<void>invoke(av); // make the flyby",
14.475 + " return target.invoke(@av[i]@); }",
14.476 + " }",
14.477 + } };
14.478 + static final String NEWLINE_INDENT = " //\n ";
14.479 + enum VAR {
14.480 + cat, N, P, Tvav, av, a0, a0_, _aN, Psp, av_i_;
14.481 + public final String pattern = "@"+toString().replace('_','.')+"@";
14.482 + public String binding = toString();
14.483 + static void makeBindings(boolean topLevel, int inargs, int pos) {
14.484 + assert(-1 <= pos && pos < inargs);
14.485 + VAR.cat.binding = "F"+inargs;
14.486 + VAR.N.binding = String.valueOf(inargs); // incoming arg count
14.487 + VAR.P.binding = String.valueOf(pos); // selected arg position
14.488 + String[] av = new String[inargs];
14.489 + String[] Tvav = new String[inargs];
14.490 + String[] av_i_ = new String[inargs];
14.491 + for (int i = 0; i < inargs; i++) {
14.492 + av[i] = arg(i);
14.493 + av_i_[i] = "av["+i+"]";
14.494 + String spc = "";
14.495 + if (i > 0 && i % 4 == 0) spc = NEWLINE_INDENT+(pos>9?" ":"")+" ";
14.496 + Tvav[i] = spc+param("Object", av[i]);
14.497 + }
14.498 + VAR.av.binding = comma(av);
14.499 + VAR.av_i_.binding = comma(av_i_);
14.500 + VAR.Tvav.binding = comma(Tvav);
14.501 + if (pos >= 0) {
14.502 + VAR.Psp.binding = (pos > 0 && pos % 10 == 0) ? NEWLINE_INDENT : "";
14.503 + String[] a0 = new String[pos];
14.504 + String[] aN = new String[inargs - (pos+1)];
14.505 + for (int i = 0; i < pos; i++) {
14.506 + String spc = "";
14.507 + if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
14.508 + a0[i] = spc+av[i];
14.509 + }
14.510 + VAR.a0.binding = comma(a0);
14.511 + VAR.a0_.binding = comma(a0, ", ");
14.512 + for (int i = pos+1; i < inargs; i++) {
14.513 + String spc = "";
14.514 + if (i > 0 && i % 10 == 0) spc = NEWLINE_INDENT;
14.515 + aN[i - (pos+1)] = spc+av[i];
14.516 + }
14.517 + VAR._aN.binding = comma(", ", aN);
14.518 + }
14.519 + }
14.520 + static String arg(int i) { return "a"+i; }
14.521 + static String param(String t, String a) { return t+" "+a; }
14.522 + static String comma(String[] v) { return comma(v, ""); }
14.523 + static String comma(String[] v, String sep) { return comma("", v, sep); }
14.524 + static String comma(String sep, String[] v) { return comma(sep, v, ""); }
14.525 + static String comma(String sep1, String[] v, String sep2) {
14.526 + if (v.length == 0) return "";
14.527 + String res = v[0];
14.528 + for (int i = 1; i < v.length; i++) res += ", "+v[i];
14.529 + return sep1 + res + sep2;
14.530 + }
14.531 + static String transform(String string) {
14.532 + for (VAR var : values())
14.533 + string = string.replaceAll(var.pattern, var.binding);
14.534 + return string;
14.535 + }
14.536 + }
14.537 + static String[] stringsIn(String[] strings, int beg, int end) {
14.538 + return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
14.539 + }
14.540 + static String[] stringsBefore(String[] strings, int pos) {
14.541 + return stringsIn(strings, 0, pos);
14.542 + }
14.543 + static String[] stringsAfter(String[] strings, int pos) {
14.544 + return stringsIn(strings, pos, strings.length);
14.545 + }
14.546 + static int indexAfter(String[] strings, int pos, String tag) {
14.547 + return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
14.548 + }
14.549 + static int indexBefore(String[] strings, int pos, String tag) {
14.550 + for (int i = pos, end = strings.length; ; i++) {
14.551 + if (i == end || strings[i].endsWith(tag)) return i;
14.552 + }
14.553 + }
14.554 + static int MIN_ARITY, MAX_ARITY;
14.555 + public static void main(String... av) {
14.556 + for (String[] template : TEMPLATES) {
14.557 + int forLinesLimit = indexBefore(template, 0, "@each-cat@");
14.558 + String[] forLines = stringsBefore(template, forLinesLimit);
14.559 + template = stringsAfter(template, forLinesLimit);
14.560 + for (String forLine : forLines)
14.561 + expandTemplate(forLine, template);
14.562 + }
14.563 + }
14.564 + static void expandTemplate(String forLine, String[] template) {
14.565 + String[] params = forLine.split("[^0-9]+");
14.566 + if (params[0].length() == 0) params = stringsAfter(params, 1);
14.567 + System.out.println("//params="+Arrays.asList(params));
14.568 + int pcur = 0;
14.569 + MIN_ARITY = Integer.valueOf(params[pcur++]);
14.570 + MAX_ARITY = Integer.valueOf(params[pcur++]);
14.571 + if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
14.572 + for (int inargs = MIN_ARITY; inargs <= MAX_ARITY; inargs++) {
14.573 + expandTemplate(template, true, inargs, -1);
14.574 + }
14.575 + }
14.576 + static void expandTemplate(String[] template, boolean topLevel, int inargs, int pos) {
14.577 + VAR.makeBindings(topLevel, inargs, pos);
14.578 + for (int i = 0; i < template.length; i++) {
14.579 + String line = template[i];
14.580 + if (line.endsWith("@each-cat@")) {
14.581 + // ignore
14.582 + } else if (line.endsWith("@each-P@")) {
14.583 + int blockEnd = indexAfter(template, i, "@end-P@");
14.584 + String[] block = stringsIn(template, i+1, blockEnd-1);
14.585 + for (int pos1 = Math.max(0,pos); pos1 < inargs; pos1++)
14.586 + expandTemplate(block, false, inargs, pos1);
14.587 + VAR.makeBindings(topLevel, inargs, pos);
14.588 + i = blockEnd-1; continue;
14.589 + } else {
14.590 + System.out.println(VAR.transform(line));
14.591 + }
14.592 + }
14.593 + }
14.594 }
14.595 +//}}} */
14.596 +//params=[1, 20]
14.597 + static class F1 extends Adapter {
14.598 + protected F1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.599 + protected F1(MethodHandle e, MethodHandle f, MethodHandle t) {
14.600 + super(e, f, t); }
14.601 + protected F1 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.602 + return new F1(e, f, t); }
14.603 + protected Object invoke_V0(Object a0) throws Throwable {
14.604 + return target.invoke(filter.invoke(a0)); }
14.605 + protected Object invoke_F0(Object a0) throws Throwable {
14.606 + return target.invoke(filter.invoke(),
14.607 + a0); }
14.608 + protected Object invoke_F1(Object a0) throws Throwable {
14.609 + return target.invoke(filter.invoke(a0),
14.610 + a0); }
14.611 + protected Object invoke_C0(Object a0) throws Throwable {
14.612 + return target.invoke(filter.invoke(a0)); }
14.613 + protected Object invoke_C1(Object a0) throws Throwable {
14.614 + return target.invoke(a0, filter.invoke()); }
14.615 + protected Object invoke_Y0(Object a0) throws Throwable {
14.616 + Object[] av = { a0 };
14.617 + filter.<void>invoke(av); // make the flyby
14.618 + return target.invoke(av[0]); }
14.619 + }
14.620 + static class F2 extends Adapter {
14.621 + protected F2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.622 + protected F2(MethodHandle e, MethodHandle f, MethodHandle t) {
14.623 + super(e, f, t); }
14.624 + protected F2 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.625 + return new F2(e, f, t); }
14.626 + protected Object invoke_V0(Object a0, Object a1) throws Throwable {
14.627 + return target.invoke(filter.invoke(a0), a1); }
14.628 + protected Object invoke_V1(Object a0, Object a1) throws Throwable {
14.629 + return target.invoke(a0, filter.invoke(a1)); }
14.630 + protected Object invoke_F0(Object a0, Object a1) throws Throwable {
14.631 + return target.invoke(filter.invoke(),
14.632 + a0, a1); }
14.633 + protected Object invoke_F1(Object a0, Object a1) throws Throwable {
14.634 + return target.invoke(filter.invoke(a0),
14.635 + a0, a1); }
14.636 + protected Object invoke_F2(Object a0, Object a1) throws Throwable {
14.637 + return target.invoke(filter.invoke(a0, a1),
14.638 + a0, a1); }
14.639 + protected Object invoke_C0(Object a0, Object a1) throws Throwable {
14.640 + return target.invoke(filter.invoke(a0, a1)); }
14.641 + protected Object invoke_C1(Object a0, Object a1) throws Throwable {
14.642 + return target.invoke(a0, filter.invoke(a1)); }
14.643 + protected Object invoke_C2(Object a0, Object a1) throws Throwable {
14.644 + return target.invoke(a0, a1, filter.invoke()); }
14.645 + protected Object invoke_Y0(Object a0, Object a1) throws Throwable {
14.646 + Object[] av = { a0, a1 };
14.647 + filter.<void>invoke(av); // make the flyby
14.648 + return target.invoke(av[0], av[1]); }
14.649 + }
14.650 + static class F3 extends Adapter {
14.651 + protected F3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.652 + protected F3(MethodHandle e, MethodHandle f, MethodHandle t) {
14.653 + super(e, f, t); }
14.654 + protected F3 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.655 + return new F3(e, f, t); }
14.656 + protected Object invoke_V0(Object a0, Object a1, Object a2) throws Throwable {
14.657 + return target.invoke(filter.invoke(a0), a1, a2); }
14.658 + protected Object invoke_V1(Object a0, Object a1, Object a2) throws Throwable {
14.659 + return target.invoke(a0, filter.invoke(a1), a2); }
14.660 + protected Object invoke_V2(Object a0, Object a1, Object a2) throws Throwable {
14.661 + return target.invoke(a0, a1, filter.invoke(a2)); }
14.662 + protected Object invoke_F0(Object a0, Object a1, Object a2) throws Throwable {
14.663 + return target.invoke(filter.invoke(),
14.664 + a0, a1, a2); }
14.665 + protected Object invoke_F1(Object a0, Object a1, Object a2) throws Throwable {
14.666 + return target.invoke(filter.invoke(a0),
14.667 + a0, a1, a2); }
14.668 + protected Object invoke_F2(Object a0, Object a1, Object a2) throws Throwable {
14.669 + return target.invoke(filter.invoke(a0, a1),
14.670 + a0, a1, a2); }
14.671 + protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable {
14.672 + return target.invoke(filter.invoke(a0, a1, a2),
14.673 + a0, a1, a2); }
14.674 + protected Object invoke_C0(Object a0, Object a1, Object a2) throws Throwable {
14.675 + return target.invoke(filter.invoke(a0, a1, a2)); }
14.676 + protected Object invoke_C1(Object a0, Object a1, Object a2) throws Throwable {
14.677 + return target.invoke(a0, filter.invoke(a1, a2)); }
14.678 + protected Object invoke_C2(Object a0, Object a1, Object a2) throws Throwable {
14.679 + return target.invoke(a0, a1, filter.invoke(a2)); }
14.680 + protected Object invoke_C3(Object a0, Object a1, Object a2) throws Throwable {
14.681 + return target.invoke(a0, a1, a2, filter.invoke()); }
14.682 + protected Object invoke_Y0(Object a0, Object a1, Object a2) throws Throwable {
14.683 + Object[] av = { a0, a1, a2 };
14.684 + filter.<void>invoke(av); // make the flyby
14.685 + return target.invoke(av[0], av[1], av[2]); }
14.686 + }
14.687 + static class F4 extends Adapter {
14.688 + protected F4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.689 + protected F4(MethodHandle e, MethodHandle f, MethodHandle t) {
14.690 + super(e, f, t); }
14.691 + protected F4 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.692 + return new F4(e, f, t); }
14.693 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.694 + return target.invoke(filter.invoke(a0), a1, a2, a3); }
14.695 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.696 + return target.invoke(a0, filter.invoke(a1), a2, a3); }
14.697 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.698 + return target.invoke(a0, a1, filter.invoke(a2), a3); }
14.699 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.700 + return target.invoke(a0, a1, a2, filter.invoke(a3)); }
14.701 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.702 + return target.invoke(filter.invoke(),
14.703 + a0, a1, a2, a3); }
14.704 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.705 + return target.invoke(filter.invoke(a0),
14.706 + a0, a1, a2, a3); }
14.707 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.708 + return target.invoke(filter.invoke(a0, a1),
14.709 + a0, a1, a2, a3); }
14.710 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.711 + return target.invoke(filter.invoke(a0, a1, a2),
14.712 + a0, a1, a2, a3); }
14.713 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.714 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.715 + a0, a1, a2, a3); }
14.716 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.717 + return target.invoke(filter.invoke(a0, a1, a2, a3)); }
14.718 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.719 + return target.invoke(a0, filter.invoke(a1, a2, a3)); }
14.720 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.721 + return target.invoke(a0, a1, filter.invoke(a2, a3)); }
14.722 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.723 + return target.invoke(a0, a1, a2, filter.invoke(a3)); }
14.724 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.725 + return target.invoke(a0, a1, a2, a3, filter.invoke()); }
14.726 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3) throws Throwable {
14.727 + Object[] av = { a0, a1, a2, a3 };
14.728 + filter.<void>invoke(av); // make the flyby
14.729 + return target.invoke(av[0], av[1], av[2], av[3]); }
14.730 + }
14.731 + static class F5 extends Adapter {
14.732 + protected F5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.733 + protected F5(MethodHandle e, MethodHandle f, MethodHandle t) {
14.734 + super(e, f, t); }
14.735 + protected F5 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.736 + return new F5(e, f, t); }
14.737 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.738 + Object a4) throws Throwable {
14.739 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4); }
14.740 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.741 + Object a4) throws Throwable {
14.742 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4); }
14.743 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.744 + Object a4) throws Throwable {
14.745 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4); }
14.746 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.747 + Object a4) throws Throwable {
14.748 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4); }
14.749 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.750 + Object a4) throws Throwable {
14.751 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4)); }
14.752 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.753 + Object a4) throws Throwable {
14.754 + return target.invoke(filter.invoke(),
14.755 + a0, a1, a2, a3, a4); }
14.756 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.757 + Object a4) throws Throwable {
14.758 + return target.invoke(filter.invoke(a0),
14.759 + a0, a1, a2, a3, a4); }
14.760 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.761 + Object a4) throws Throwable {
14.762 + return target.invoke(filter.invoke(a0, a1),
14.763 + a0, a1, a2, a3, a4); }
14.764 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.765 + Object a4) throws Throwable {
14.766 + return target.invoke(filter.invoke(a0, a1, a2),
14.767 + a0, a1, a2, a3, a4); }
14.768 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.769 + Object a4) throws Throwable {
14.770 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.771 + a0, a1, a2, a3, a4); }
14.772 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.773 + Object a4) throws Throwable {
14.774 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.775 + a0, a1, a2, a3, a4); }
14.776 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.777 + Object a4) throws Throwable {
14.778 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4)); }
14.779 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.780 + Object a4) throws Throwable {
14.781 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4)); }
14.782 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.783 + Object a4) throws Throwable {
14.784 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4)); }
14.785 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.786 + Object a4) throws Throwable {
14.787 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4)); }
14.788 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.789 + Object a4) throws Throwable {
14.790 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4)); }
14.791 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.792 + Object a4) throws Throwable {
14.793 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke()); }
14.794 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.795 + Object a4) throws Throwable {
14.796 + Object[] av = { a0, a1, a2, a3, a4 };
14.797 + filter.<void>invoke(av); // make the flyby
14.798 + return target.invoke(av[0], av[1], av[2], av[3], av[4]); }
14.799 + }
14.800 + static class F6 extends Adapter {
14.801 + protected F6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.802 + protected F6(MethodHandle e, MethodHandle f, MethodHandle t) {
14.803 + super(e, f, t); }
14.804 + protected F6 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.805 + return new F6(e, f, t); }
14.806 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.807 + Object a4, Object a5) throws Throwable {
14.808 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5); }
14.809 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.810 + Object a4, Object a5) throws Throwable {
14.811 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5); }
14.812 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.813 + Object a4, Object a5) throws Throwable {
14.814 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5); }
14.815 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.816 + Object a4, Object a5) throws Throwable {
14.817 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5); }
14.818 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.819 + Object a4, Object a5) throws Throwable {
14.820 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5); }
14.821 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.822 + Object a4, Object a5) throws Throwable {
14.823 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5)); }
14.824 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.825 + Object a4, Object a5) throws Throwable {
14.826 + return target.invoke(filter.invoke(),
14.827 + a0, a1, a2, a3, a4, a5); }
14.828 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.829 + Object a4, Object a5) throws Throwable {
14.830 + return target.invoke(filter.invoke(a0),
14.831 + a0, a1, a2, a3, a4, a5); }
14.832 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.833 + Object a4, Object a5) throws Throwable {
14.834 + return target.invoke(filter.invoke(a0, a1),
14.835 + a0, a1, a2, a3, a4, a5); }
14.836 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.837 + Object a4, Object a5) throws Throwable {
14.838 + return target.invoke(filter.invoke(a0, a1, a2),
14.839 + a0, a1, a2, a3, a4, a5); }
14.840 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.841 + Object a4, Object a5) throws Throwable {
14.842 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.843 + a0, a1, a2, a3, a4, a5); }
14.844 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.845 + Object a4, Object a5) throws Throwable {
14.846 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.847 + a0, a1, a2, a3, a4, a5); }
14.848 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.849 + Object a4, Object a5) throws Throwable {
14.850 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.851 + a0, a1, a2, a3, a4, a5); }
14.852 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.853 + Object a4, Object a5) throws Throwable {
14.854 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5)); }
14.855 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.856 + Object a4, Object a5) throws Throwable {
14.857 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5)); }
14.858 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.859 + Object a4, Object a5) throws Throwable {
14.860 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5)); }
14.861 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.862 + Object a4, Object a5) throws Throwable {
14.863 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5)); }
14.864 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.865 + Object a4, Object a5) throws Throwable {
14.866 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5)); }
14.867 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.868 + Object a4, Object a5) throws Throwable {
14.869 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5)); }
14.870 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.871 + Object a4, Object a5) throws Throwable {
14.872 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke()); }
14.873 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.874 + Object a4, Object a5) throws Throwable {
14.875 + Object[] av = { a0, a1, a2, a3, a4, a5 };
14.876 + filter.<void>invoke(av); // make the flyby
14.877 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5]); }
14.878 + }
14.879 + static class F7 extends Adapter {
14.880 + protected F7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.881 + protected F7(MethodHandle e, MethodHandle f, MethodHandle t) {
14.882 + super(e, f, t); }
14.883 + protected F7 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.884 + return new F7(e, f, t); }
14.885 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.886 + Object a4, Object a5, Object a6) throws Throwable {
14.887 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6); }
14.888 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.889 + Object a4, Object a5, Object a6) throws Throwable {
14.890 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6); }
14.891 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.892 + Object a4, Object a5, Object a6) throws Throwable {
14.893 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6); }
14.894 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.895 + Object a4, Object a5, Object a6) throws Throwable {
14.896 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6); }
14.897 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.898 + Object a4, Object a5, Object a6) throws Throwable {
14.899 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6); }
14.900 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.901 + Object a4, Object a5, Object a6) throws Throwable {
14.902 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6); }
14.903 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.904 + Object a4, Object a5, Object a6) throws Throwable {
14.905 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6)); }
14.906 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.907 + Object a4, Object a5, Object a6) throws Throwable {
14.908 + return target.invoke(filter.invoke(),
14.909 + a0, a1, a2, a3, a4, a5, a6); }
14.910 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.911 + Object a4, Object a5, Object a6) throws Throwable {
14.912 + return target.invoke(filter.invoke(a0),
14.913 + a0, a1, a2, a3, a4, a5, a6); }
14.914 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.915 + Object a4, Object a5, Object a6) throws Throwable {
14.916 + return target.invoke(filter.invoke(a0, a1),
14.917 + a0, a1, a2, a3, a4, a5, a6); }
14.918 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.919 + Object a4, Object a5, Object a6) throws Throwable {
14.920 + return target.invoke(filter.invoke(a0, a1, a2),
14.921 + a0, a1, a2, a3, a4, a5, a6); }
14.922 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.923 + Object a4, Object a5, Object a6) throws Throwable {
14.924 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.925 + a0, a1, a2, a3, a4, a5, a6); }
14.926 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.927 + Object a4, Object a5, Object a6) throws Throwable {
14.928 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.929 + a0, a1, a2, a3, a4, a5, a6); }
14.930 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.931 + Object a4, Object a5, Object a6) throws Throwable {
14.932 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.933 + a0, a1, a2, a3, a4, a5, a6); }
14.934 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.935 + Object a4, Object a5, Object a6) throws Throwable {
14.936 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.937 + a0, a1, a2, a3, a4, a5, a6); }
14.938 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.939 + Object a4, Object a5, Object a6) throws Throwable {
14.940 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6)); }
14.941 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.942 + Object a4, Object a5, Object a6) throws Throwable {
14.943 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6)); }
14.944 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.945 + Object a4, Object a5, Object a6) throws Throwable {
14.946 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6)); }
14.947 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.948 + Object a4, Object a5, Object a6) throws Throwable {
14.949 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6)); }
14.950 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.951 + Object a4, Object a5, Object a6) throws Throwable {
14.952 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6)); }
14.953 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.954 + Object a4, Object a5, Object a6) throws Throwable {
14.955 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6)); }
14.956 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.957 + Object a4, Object a5, Object a6) throws Throwable {
14.958 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6)); }
14.959 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.960 + Object a4, Object a5, Object a6) throws Throwable {
14.961 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke()); }
14.962 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.963 + Object a4, Object a5, Object a6) throws Throwable {
14.964 + Object[] av = { a0, a1, a2, a3, a4, a5, a6 };
14.965 + filter.<void>invoke(av); // make the flyby
14.966 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6]); }
14.967 + }
14.968 + static class F8 extends Adapter {
14.969 + protected F8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.970 + protected F8(MethodHandle e, MethodHandle f, MethodHandle t) {
14.971 + super(e, f, t); }
14.972 + protected F8 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.973 + return new F8(e, f, t); }
14.974 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.975 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.976 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7); }
14.977 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.978 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.979 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7); }
14.980 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.981 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.982 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7); }
14.983 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.984 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.985 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7); }
14.986 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.987 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.988 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7); }
14.989 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.990 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.991 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7); }
14.992 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.993 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.994 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7); }
14.995 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.996 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.997 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7)); }
14.998 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.999 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1000 + return target.invoke(filter.invoke(),
14.1001 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1002 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1003 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1004 + return target.invoke(filter.invoke(a0),
14.1005 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1006 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1007 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1008 + return target.invoke(filter.invoke(a0, a1),
14.1009 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1010 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1011 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1012 + return target.invoke(filter.invoke(a0, a1, a2),
14.1013 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1014 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1015 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1016 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1017 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1018 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1019 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1020 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1021 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1022 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1023 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1024 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1025 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1026 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1027 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1028 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1029 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1030 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1031 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1032 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1033 + a0, a1, a2, a3, a4, a5, a6, a7); }
14.1034 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1035 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1036 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7)); }
14.1037 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1038 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1039 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7)); }
14.1040 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1041 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1042 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7)); }
14.1043 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1044 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1045 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7)); }
14.1046 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1047 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1048 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7)); }
14.1049 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1050 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1051 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7)); }
14.1052 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1053 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1054 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7)); }
14.1055 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1056 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1057 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7)); }
14.1058 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1059 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1060 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke()); }
14.1061 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1062 + Object a4, Object a5, Object a6, Object a7) throws Throwable {
14.1063 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7 };
14.1064 + filter.<void>invoke(av); // make the flyby
14.1065 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7]); }
14.1066 + }
14.1067 + static class F9 extends Adapter {
14.1068 + protected F9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.1069 + protected F9(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1070 + super(e, f, t); }
14.1071 + protected F9 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1072 + return new F9(e, f, t); }
14.1073 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.1074 + Object a4, Object a5, Object a6, Object a7,
14.1075 + Object a8) throws Throwable {
14.1076 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8); }
14.1077 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.1078 + Object a4, Object a5, Object a6, Object a7,
14.1079 + Object a8) throws Throwable {
14.1080 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8); }
14.1081 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.1082 + Object a4, Object a5, Object a6, Object a7,
14.1083 + Object a8) throws Throwable {
14.1084 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8); }
14.1085 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.1086 + Object a4, Object a5, Object a6, Object a7,
14.1087 + Object a8) throws Throwable {
14.1088 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8); }
14.1089 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.1090 + Object a4, Object a5, Object a6, Object a7,
14.1091 + Object a8) throws Throwable {
14.1092 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8); }
14.1093 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.1094 + Object a4, Object a5, Object a6, Object a7,
14.1095 + Object a8) throws Throwable {
14.1096 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8); }
14.1097 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.1098 + Object a4, Object a5, Object a6, Object a7,
14.1099 + Object a8) throws Throwable {
14.1100 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8); }
14.1101 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.1102 + Object a4, Object a5, Object a6, Object a7,
14.1103 + Object a8) throws Throwable {
14.1104 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8); }
14.1105 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.1106 + Object a4, Object a5, Object a6, Object a7,
14.1107 + Object a8) throws Throwable {
14.1108 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8)); }
14.1109 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.1110 + Object a4, Object a5, Object a6, Object a7,
14.1111 + Object a8) throws Throwable {
14.1112 + return target.invoke(filter.invoke(),
14.1113 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1114 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1115 + Object a4, Object a5, Object a6, Object a7,
14.1116 + Object a8) throws Throwable {
14.1117 + return target.invoke(filter.invoke(a0),
14.1118 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1119 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1120 + Object a4, Object a5, Object a6, Object a7,
14.1121 + Object a8) throws Throwable {
14.1122 + return target.invoke(filter.invoke(a0, a1),
14.1123 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1124 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1125 + Object a4, Object a5, Object a6, Object a7,
14.1126 + Object a8) throws Throwable {
14.1127 + return target.invoke(filter.invoke(a0, a1, a2),
14.1128 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1129 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1130 + Object a4, Object a5, Object a6, Object a7,
14.1131 + Object a8) throws Throwable {
14.1132 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1133 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1134 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1135 + Object a4, Object a5, Object a6, Object a7,
14.1136 + Object a8) throws Throwable {
14.1137 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1138 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1139 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1140 + Object a4, Object a5, Object a6, Object a7,
14.1141 + Object a8) throws Throwable {
14.1142 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1143 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1144 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1145 + Object a4, Object a5, Object a6, Object a7,
14.1146 + Object a8) throws Throwable {
14.1147 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1148 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1149 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1150 + Object a4, Object a5, Object a6, Object a7,
14.1151 + Object a8) throws Throwable {
14.1152 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1153 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1154 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.1155 + Object a4, Object a5, Object a6, Object a7,
14.1156 + Object a8) throws Throwable {
14.1157 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.1158 + a0, a1, a2, a3, a4, a5, a6, a7, a8); }
14.1159 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1160 + Object a4, Object a5, Object a6, Object a7,
14.1161 + Object a8) throws Throwable {
14.1162 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
14.1163 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1164 + Object a4, Object a5, Object a6, Object a7,
14.1165 + Object a8) throws Throwable {
14.1166 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8)); }
14.1167 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1168 + Object a4, Object a5, Object a6, Object a7,
14.1169 + Object a8) throws Throwable {
14.1170 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8)); }
14.1171 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1172 + Object a4, Object a5, Object a6, Object a7,
14.1173 + Object a8) throws Throwable {
14.1174 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8)); }
14.1175 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1176 + Object a4, Object a5, Object a6, Object a7,
14.1177 + Object a8) throws Throwable {
14.1178 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8)); }
14.1179 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1180 + Object a4, Object a5, Object a6, Object a7,
14.1181 + Object a8) throws Throwable {
14.1182 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8)); }
14.1183 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1184 + Object a4, Object a5, Object a6, Object a7,
14.1185 + Object a8) throws Throwable {
14.1186 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8)); }
14.1187 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1188 + Object a4, Object a5, Object a6, Object a7,
14.1189 + Object a8) throws Throwable {
14.1190 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8)); }
14.1191 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1192 + Object a4, Object a5, Object a6, Object a7,
14.1193 + Object a8) throws Throwable {
14.1194 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8)); }
14.1195 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.1196 + Object a4, Object a5, Object a6, Object a7,
14.1197 + Object a8) throws Throwable {
14.1198 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke()); }
14.1199 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1200 + Object a4, Object a5, Object a6, Object a7,
14.1201 + Object a8) throws Throwable {
14.1202 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8 };
14.1203 + filter.<void>invoke(av); // make the flyby
14.1204 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8]); }
14.1205 + }
14.1206 + static class F10 extends Adapter {
14.1207 + protected F10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.1208 + protected F10(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1209 + super(e, f, t); }
14.1210 + protected F10 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1211 + return new F10(e, f, t); }
14.1212 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.1213 + Object a4, Object a5, Object a6, Object a7,
14.1214 + Object a8, Object a9) throws Throwable {
14.1215 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1216 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.1217 + Object a4, Object a5, Object a6, Object a7,
14.1218 + Object a8, Object a9) throws Throwable {
14.1219 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9); }
14.1220 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.1221 + Object a4, Object a5, Object a6, Object a7,
14.1222 + Object a8, Object a9) throws Throwable {
14.1223 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9); }
14.1224 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.1225 + Object a4, Object a5, Object a6, Object a7,
14.1226 + Object a8, Object a9) throws Throwable {
14.1227 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9); }
14.1228 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.1229 + Object a4, Object a5, Object a6, Object a7,
14.1230 + Object a8, Object a9) throws Throwable {
14.1231 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9); }
14.1232 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.1233 + Object a4, Object a5, Object a6, Object a7,
14.1234 + Object a8, Object a9) throws Throwable {
14.1235 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9); }
14.1236 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.1237 + Object a4, Object a5, Object a6, Object a7,
14.1238 + Object a8, Object a9) throws Throwable {
14.1239 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9); }
14.1240 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.1241 + Object a4, Object a5, Object a6, Object a7,
14.1242 + Object a8, Object a9) throws Throwable {
14.1243 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9); }
14.1244 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.1245 + Object a4, Object a5, Object a6, Object a7,
14.1246 + Object a8, Object a9) throws Throwable {
14.1247 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9); }
14.1248 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.1249 + Object a4, Object a5, Object a6, Object a7,
14.1250 + Object a8, Object a9) throws Throwable {
14.1251 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9)); }
14.1252 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.1253 + Object a4, Object a5, Object a6, Object a7,
14.1254 + Object a8, Object a9) throws Throwable {
14.1255 + return target.invoke(filter.invoke(),
14.1256 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1257 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1258 + Object a4, Object a5, Object a6, Object a7,
14.1259 + Object a8, Object a9) throws Throwable {
14.1260 + return target.invoke(filter.invoke(a0),
14.1261 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1262 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1263 + Object a4, Object a5, Object a6, Object a7,
14.1264 + Object a8, Object a9) throws Throwable {
14.1265 + return target.invoke(filter.invoke(a0, a1),
14.1266 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1267 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1268 + Object a4, Object a5, Object a6, Object a7,
14.1269 + Object a8, Object a9) throws Throwable {
14.1270 + return target.invoke(filter.invoke(a0, a1, a2),
14.1271 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1272 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1273 + Object a4, Object a5, Object a6, Object a7,
14.1274 + Object a8, Object a9) throws Throwable {
14.1275 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1276 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1277 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1278 + Object a4, Object a5, Object a6, Object a7,
14.1279 + Object a8, Object a9) throws Throwable {
14.1280 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1281 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1282 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1283 + Object a4, Object a5, Object a6, Object a7,
14.1284 + Object a8, Object a9) throws Throwable {
14.1285 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1286 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1287 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1288 + Object a4, Object a5, Object a6, Object a7,
14.1289 + Object a8, Object a9) throws Throwable {
14.1290 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1291 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1292 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1293 + Object a4, Object a5, Object a6, Object a7,
14.1294 + Object a8, Object a9) throws Throwable {
14.1295 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1296 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1297 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.1298 + Object a4, Object a5, Object a6, Object a7,
14.1299 + Object a8, Object a9) throws Throwable {
14.1300 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.1301 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1302 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.1303 + Object a4, Object a5, Object a6, Object a7,
14.1304 + Object a8, Object a9) throws Throwable {
14.1305 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.1306 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
14.1307 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1308 + Object a4, Object a5, Object a6, Object a7,
14.1309 + Object a8, Object a9) throws Throwable {
14.1310 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
14.1311 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1312 + Object a4, Object a5, Object a6, Object a7,
14.1313 + Object a8, Object a9) throws Throwable {
14.1314 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
14.1315 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1316 + Object a4, Object a5, Object a6, Object a7,
14.1317 + Object a8, Object a9) throws Throwable {
14.1318 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9)); }
14.1319 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1320 + Object a4, Object a5, Object a6, Object a7,
14.1321 + Object a8, Object a9) throws Throwable {
14.1322 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9)); }
14.1323 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1324 + Object a4, Object a5, Object a6, Object a7,
14.1325 + Object a8, Object a9) throws Throwable {
14.1326 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9)); }
14.1327 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1328 + Object a4, Object a5, Object a6, Object a7,
14.1329 + Object a8, Object a9) throws Throwable {
14.1330 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9)); }
14.1331 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1332 + Object a4, Object a5, Object a6, Object a7,
14.1333 + Object a8, Object a9) throws Throwable {
14.1334 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9)); }
14.1335 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1336 + Object a4, Object a5, Object a6, Object a7,
14.1337 + Object a8, Object a9) throws Throwable {
14.1338 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9)); }
14.1339 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1340 + Object a4, Object a5, Object a6, Object a7,
14.1341 + Object a8, Object a9) throws Throwable {
14.1342 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9)); }
14.1343 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.1344 + Object a4, Object a5, Object a6, Object a7,
14.1345 + Object a8, Object a9) throws Throwable {
14.1346 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9)); }
14.1347 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.1348 + Object a4, Object a5, Object a6, Object a7,
14.1349 + Object a8, Object a9) throws Throwable {
14.1350 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke()); }
14.1351 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1352 + Object a4, Object a5, Object a6, Object a7,
14.1353 + Object a8, Object a9) throws Throwable {
14.1354 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 };
14.1355 + filter.<void>invoke(av); // make the flyby
14.1356 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9]); }
14.1357 + }
14.1358 + static class F11 extends Adapter {
14.1359 + protected F11(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.1360 + protected F11(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1361 + super(e, f, t); }
14.1362 + protected F11 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1363 + return new F11(e, f, t); }
14.1364 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.1365 + Object a4, Object a5, Object a6, Object a7,
14.1366 + Object a8, Object a9, Object a10) throws Throwable {
14.1367 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1368 + a10); }
14.1369 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.1370 + Object a4, Object a5, Object a6, Object a7,
14.1371 + Object a8, Object a9, Object a10) throws Throwable {
14.1372 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.1373 + a10); }
14.1374 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.1375 + Object a4, Object a5, Object a6, Object a7,
14.1376 + Object a8, Object a9, Object a10) throws Throwable {
14.1377 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.1378 + a10); }
14.1379 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.1380 + Object a4, Object a5, Object a6, Object a7,
14.1381 + Object a8, Object a9, Object a10) throws Throwable {
14.1382 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.1383 + a10); }
14.1384 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.1385 + Object a4, Object a5, Object a6, Object a7,
14.1386 + Object a8, Object a9, Object a10) throws Throwable {
14.1387 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.1388 + a10); }
14.1389 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.1390 + Object a4, Object a5, Object a6, Object a7,
14.1391 + Object a8, Object a9, Object a10) throws Throwable {
14.1392 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.1393 + a10); }
14.1394 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.1395 + Object a4, Object a5, Object a6, Object a7,
14.1396 + Object a8, Object a9, Object a10) throws Throwable {
14.1397 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.1398 + a10); }
14.1399 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.1400 + Object a4, Object a5, Object a6, Object a7,
14.1401 + Object a8, Object a9, Object a10) throws Throwable {
14.1402 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.1403 + a10); }
14.1404 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.1405 + Object a4, Object a5, Object a6, Object a7,
14.1406 + Object a8, Object a9, Object a10) throws Throwable {
14.1407 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.1408 + a10); }
14.1409 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.1410 + Object a4, Object a5, Object a6, Object a7,
14.1411 + Object a8, Object a9, Object a10) throws Throwable {
14.1412 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.1413 + a10); }
14.1414 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.1415 + Object a4, Object a5, Object a6, Object a7,
14.1416 + Object a8, Object a9, Object a10) throws Throwable {
14.1417 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1418 + filter.invoke(a10)); }
14.1419 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.1420 + Object a4, Object a5, Object a6, Object a7,
14.1421 + Object a8, Object a9, Object a10) throws Throwable {
14.1422 + return target.invoke(filter.invoke(),
14.1423 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1424 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1425 + Object a4, Object a5, Object a6, Object a7,
14.1426 + Object a8, Object a9, Object a10) throws Throwable {
14.1427 + return target.invoke(filter.invoke(a0),
14.1428 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1429 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1430 + Object a4, Object a5, Object a6, Object a7,
14.1431 + Object a8, Object a9, Object a10) throws Throwable {
14.1432 + return target.invoke(filter.invoke(a0, a1),
14.1433 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1434 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1435 + Object a4, Object a5, Object a6, Object a7,
14.1436 + Object a8, Object a9, Object a10) throws Throwable {
14.1437 + return target.invoke(filter.invoke(a0, a1, a2),
14.1438 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1439 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1440 + Object a4, Object a5, Object a6, Object a7,
14.1441 + Object a8, Object a9, Object a10) throws Throwable {
14.1442 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1443 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1444 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1445 + Object a4, Object a5, Object a6, Object a7,
14.1446 + Object a8, Object a9, Object a10) throws Throwable {
14.1447 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1448 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1449 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1450 + Object a4, Object a5, Object a6, Object a7,
14.1451 + Object a8, Object a9, Object a10) throws Throwable {
14.1452 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1453 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1454 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1455 + Object a4, Object a5, Object a6, Object a7,
14.1456 + Object a8, Object a9, Object a10) throws Throwable {
14.1457 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1458 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1459 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1460 + Object a4, Object a5, Object a6, Object a7,
14.1461 + Object a8, Object a9, Object a10) throws Throwable {
14.1462 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1463 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1464 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.1465 + Object a4, Object a5, Object a6, Object a7,
14.1466 + Object a8, Object a9, Object a10) throws Throwable {
14.1467 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.1468 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1469 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.1470 + Object a4, Object a5, Object a6, Object a7,
14.1471 + Object a8, Object a9, Object a10) throws Throwable {
14.1472 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.1473 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1474 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.1475 + Object a4, Object a5, Object a6, Object a7,
14.1476 + Object a8, Object a9, Object a10) throws Throwable {
14.1477 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10),
14.1478 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
14.1479 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1480 + Object a4, Object a5, Object a6, Object a7,
14.1481 + Object a8, Object a9, Object a10) throws Throwable {
14.1482 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1483 + a10)); }
14.1484 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1485 + Object a4, Object a5, Object a6, Object a7,
14.1486 + Object a8, Object a9, Object a10) throws Throwable {
14.1487 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1488 + a10)); }
14.1489 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1490 + Object a4, Object a5, Object a6, Object a7,
14.1491 + Object a8, Object a9, Object a10) throws Throwable {
14.1492 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.1493 + a10)); }
14.1494 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1495 + Object a4, Object a5, Object a6, Object a7,
14.1496 + Object a8, Object a9, Object a10) throws Throwable {
14.1497 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.1498 + a10)); }
14.1499 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1500 + Object a4, Object a5, Object a6, Object a7,
14.1501 + Object a8, Object a9, Object a10) throws Throwable {
14.1502 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.1503 + a10)); }
14.1504 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1505 + Object a4, Object a5, Object a6, Object a7,
14.1506 + Object a8, Object a9, Object a10) throws Throwable {
14.1507 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.1508 + a10)); }
14.1509 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1510 + Object a4, Object a5, Object a6, Object a7,
14.1511 + Object a8, Object a9, Object a10) throws Throwable {
14.1512 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.1513 + a10)); }
14.1514 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1515 + Object a4, Object a5, Object a6, Object a7,
14.1516 + Object a8, Object a9, Object a10) throws Throwable {
14.1517 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.1518 + a10)); }
14.1519 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1520 + Object a4, Object a5, Object a6, Object a7,
14.1521 + Object a8, Object a9, Object a10) throws Throwable {
14.1522 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.1523 + a10)); }
14.1524 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.1525 + Object a4, Object a5, Object a6, Object a7,
14.1526 + Object a8, Object a9, Object a10) throws Throwable {
14.1527 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.1528 + a10)); }
14.1529 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.1530 + Object a4, Object a5, Object a6, Object a7,
14.1531 + Object a8, Object a9, Object a10) throws Throwable {
14.1532 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10)); }
14.1533 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.1534 + Object a4, Object a5, Object a6, Object a7,
14.1535 + Object a8, Object a9, Object a10) throws Throwable {
14.1536 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, filter.invoke()); }
14.1537 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1538 + Object a4, Object a5, Object a6, Object a7,
14.1539 + Object a8, Object a9, Object a10) throws Throwable {
14.1540 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 };
14.1541 + filter.<void>invoke(av); // make the flyby
14.1542 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10]); }
14.1543 + }
14.1544 + static class F12 extends Adapter {
14.1545 + protected F12(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.1546 + protected F12(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1547 + super(e, f, t); }
14.1548 + protected F12 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1549 + return new F12(e, f, t); }
14.1550 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.1551 + Object a4, Object a5, Object a6, Object a7,
14.1552 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1553 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1554 + a10, a11); }
14.1555 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.1556 + Object a4, Object a5, Object a6, Object a7,
14.1557 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1558 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.1559 + a10, a11); }
14.1560 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.1561 + Object a4, Object a5, Object a6, Object a7,
14.1562 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1563 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.1564 + a10, a11); }
14.1565 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.1566 + Object a4, Object a5, Object a6, Object a7,
14.1567 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1568 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.1569 + a10, a11); }
14.1570 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.1571 + Object a4, Object a5, Object a6, Object a7,
14.1572 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1573 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.1574 + a10, a11); }
14.1575 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.1576 + Object a4, Object a5, Object a6, Object a7,
14.1577 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1578 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.1579 + a10, a11); }
14.1580 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.1581 + Object a4, Object a5, Object a6, Object a7,
14.1582 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1583 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.1584 + a10, a11); }
14.1585 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.1586 + Object a4, Object a5, Object a6, Object a7,
14.1587 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1588 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.1589 + a10, a11); }
14.1590 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.1591 + Object a4, Object a5, Object a6, Object a7,
14.1592 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1593 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.1594 + a10, a11); }
14.1595 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.1596 + Object a4, Object a5, Object a6, Object a7,
14.1597 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1598 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.1599 + a10, a11); }
14.1600 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.1601 + Object a4, Object a5, Object a6, Object a7,
14.1602 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1603 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1604 + filter.invoke(a10), a11); }
14.1605 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.1606 + Object a4, Object a5, Object a6, Object a7,
14.1607 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1608 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1609 + a10, filter.invoke(a11)); }
14.1610 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.1611 + Object a4, Object a5, Object a6, Object a7,
14.1612 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1613 + return target.invoke(filter.invoke(),
14.1614 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1615 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1616 + Object a4, Object a5, Object a6, Object a7,
14.1617 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1618 + return target.invoke(filter.invoke(a0),
14.1619 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1620 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1621 + Object a4, Object a5, Object a6, Object a7,
14.1622 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1623 + return target.invoke(filter.invoke(a0, a1),
14.1624 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1625 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1626 + Object a4, Object a5, Object a6, Object a7,
14.1627 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1628 + return target.invoke(filter.invoke(a0, a1, a2),
14.1629 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1630 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1631 + Object a4, Object a5, Object a6, Object a7,
14.1632 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1633 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1634 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1635 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1636 + Object a4, Object a5, Object a6, Object a7,
14.1637 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1638 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1639 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1640 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1641 + Object a4, Object a5, Object a6, Object a7,
14.1642 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1643 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1644 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1645 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1646 + Object a4, Object a5, Object a6, Object a7,
14.1647 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1648 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1649 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1650 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1651 + Object a4, Object a5, Object a6, Object a7,
14.1652 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1653 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1654 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1655 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.1656 + Object a4, Object a5, Object a6, Object a7,
14.1657 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1658 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.1659 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1660 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.1661 + Object a4, Object a5, Object a6, Object a7,
14.1662 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1663 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.1664 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1665 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.1666 + Object a4, Object a5, Object a6, Object a7,
14.1667 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1668 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1669 + a10),
14.1670 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1671 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.1672 + Object a4, Object a5, Object a6, Object a7,
14.1673 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1674 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11),
14.1675 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
14.1676 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1677 + Object a4, Object a5, Object a6, Object a7,
14.1678 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1679 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1680 + a10, a11)); }
14.1681 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1682 + Object a4, Object a5, Object a6, Object a7,
14.1683 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1684 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1685 + a10, a11)); }
14.1686 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1687 + Object a4, Object a5, Object a6, Object a7,
14.1688 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1689 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.1690 + a10, a11)); }
14.1691 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1692 + Object a4, Object a5, Object a6, Object a7,
14.1693 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1694 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.1695 + a10, a11)); }
14.1696 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1697 + Object a4, Object a5, Object a6, Object a7,
14.1698 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1699 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.1700 + a10, a11)); }
14.1701 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1702 + Object a4, Object a5, Object a6, Object a7,
14.1703 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1704 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.1705 + a10, a11)); }
14.1706 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1707 + Object a4, Object a5, Object a6, Object a7,
14.1708 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1709 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.1710 + a10, a11)); }
14.1711 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1712 + Object a4, Object a5, Object a6, Object a7,
14.1713 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1714 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.1715 + a10, a11)); }
14.1716 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1717 + Object a4, Object a5, Object a6, Object a7,
14.1718 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1719 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.1720 + a10, a11)); }
14.1721 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.1722 + Object a4, Object a5, Object a6, Object a7,
14.1723 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1724 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.1725 + a10, a11)); }
14.1726 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.1727 + Object a4, Object a5, Object a6, Object a7,
14.1728 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1729 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11)); }
14.1730 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.1731 + Object a4, Object a5, Object a6, Object a7,
14.1732 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1733 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1734 + a10, filter.invoke(a11)); }
14.1735 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.1736 + Object a4, Object a5, Object a6, Object a7,
14.1737 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1738 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, filter.invoke()); }
14.1739 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1740 + Object a4, Object a5, Object a6, Object a7,
14.1741 + Object a8, Object a9, Object a10, Object a11) throws Throwable {
14.1742 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 };
14.1743 + filter.<void>invoke(av); // make the flyby
14.1744 + return target.invoke(av[0], av[1], av[2], av[3], av[4], av[5], av[6], av[7], av[8], av[9], av[10], av[11]); }
14.1745 + }
14.1746 + static class F13 extends Adapter {
14.1747 + protected F13(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.1748 + protected F13(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1749 + super(e, f, t); }
14.1750 + protected F13 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.1751 + return new F13(e, f, t); }
14.1752 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.1753 + Object a4, Object a5, Object a6, Object a7,
14.1754 + Object a8, Object a9, Object a10, Object a11,
14.1755 + Object a12) throws Throwable {
14.1756 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1757 + a10, a11, a12); }
14.1758 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.1759 + Object a4, Object a5, Object a6, Object a7,
14.1760 + Object a8, Object a9, Object a10, Object a11,
14.1761 + Object a12) throws Throwable {
14.1762 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.1763 + a10, a11, a12); }
14.1764 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.1765 + Object a4, Object a5, Object a6, Object a7,
14.1766 + Object a8, Object a9, Object a10, Object a11,
14.1767 + Object a12) throws Throwable {
14.1768 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.1769 + a10, a11, a12); }
14.1770 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.1771 + Object a4, Object a5, Object a6, Object a7,
14.1772 + Object a8, Object a9, Object a10, Object a11,
14.1773 + Object a12) throws Throwable {
14.1774 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.1775 + a10, a11, a12); }
14.1776 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.1777 + Object a4, Object a5, Object a6, Object a7,
14.1778 + Object a8, Object a9, Object a10, Object a11,
14.1779 + Object a12) throws Throwable {
14.1780 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.1781 + a10, a11, a12); }
14.1782 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.1783 + Object a4, Object a5, Object a6, Object a7,
14.1784 + Object a8, Object a9, Object a10, Object a11,
14.1785 + Object a12) throws Throwable {
14.1786 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.1787 + a10, a11, a12); }
14.1788 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.1789 + Object a4, Object a5, Object a6, Object a7,
14.1790 + Object a8, Object a9, Object a10, Object a11,
14.1791 + Object a12) throws Throwable {
14.1792 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.1793 + a10, a11, a12); }
14.1794 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.1795 + Object a4, Object a5, Object a6, Object a7,
14.1796 + Object a8, Object a9, Object a10, Object a11,
14.1797 + Object a12) throws Throwable {
14.1798 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.1799 + a10, a11, a12); }
14.1800 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.1801 + Object a4, Object a5, Object a6, Object a7,
14.1802 + Object a8, Object a9, Object a10, Object a11,
14.1803 + Object a12) throws Throwable {
14.1804 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.1805 + a10, a11, a12); }
14.1806 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.1807 + Object a4, Object a5, Object a6, Object a7,
14.1808 + Object a8, Object a9, Object a10, Object a11,
14.1809 + Object a12) throws Throwable {
14.1810 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.1811 + a10, a11, a12); }
14.1812 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.1813 + Object a4, Object a5, Object a6, Object a7,
14.1814 + Object a8, Object a9, Object a10, Object a11,
14.1815 + Object a12) throws Throwable {
14.1816 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1817 + filter.invoke(a10), a11, a12); }
14.1818 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.1819 + Object a4, Object a5, Object a6, Object a7,
14.1820 + Object a8, Object a9, Object a10, Object a11,
14.1821 + Object a12) throws Throwable {
14.1822 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1823 + a10, filter.invoke(a11), a12); }
14.1824 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.1825 + Object a4, Object a5, Object a6, Object a7,
14.1826 + Object a8, Object a9, Object a10, Object a11,
14.1827 + Object a12) throws Throwable {
14.1828 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1829 + a10, a11, filter.invoke(a12)); }
14.1830 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.1831 + Object a4, Object a5, Object a6, Object a7,
14.1832 + Object a8, Object a9, Object a10, Object a11,
14.1833 + Object a12) throws Throwable {
14.1834 + return target.invoke(filter.invoke(),
14.1835 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1836 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.1837 + Object a4, Object a5, Object a6, Object a7,
14.1838 + Object a8, Object a9, Object a10, Object a11,
14.1839 + Object a12) throws Throwable {
14.1840 + return target.invoke(filter.invoke(a0),
14.1841 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1842 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.1843 + Object a4, Object a5, Object a6, Object a7,
14.1844 + Object a8, Object a9, Object a10, Object a11,
14.1845 + Object a12) throws Throwable {
14.1846 + return target.invoke(filter.invoke(a0, a1),
14.1847 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1848 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.1849 + Object a4, Object a5, Object a6, Object a7,
14.1850 + Object a8, Object a9, Object a10, Object a11,
14.1851 + Object a12) throws Throwable {
14.1852 + return target.invoke(filter.invoke(a0, a1, a2),
14.1853 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1854 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.1855 + Object a4, Object a5, Object a6, Object a7,
14.1856 + Object a8, Object a9, Object a10, Object a11,
14.1857 + Object a12) throws Throwable {
14.1858 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.1859 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1860 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.1861 + Object a4, Object a5, Object a6, Object a7,
14.1862 + Object a8, Object a9, Object a10, Object a11,
14.1863 + Object a12) throws Throwable {
14.1864 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.1865 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1866 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.1867 + Object a4, Object a5, Object a6, Object a7,
14.1868 + Object a8, Object a9, Object a10, Object a11,
14.1869 + Object a12) throws Throwable {
14.1870 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.1871 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1872 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.1873 + Object a4, Object a5, Object a6, Object a7,
14.1874 + Object a8, Object a9, Object a10, Object a11,
14.1875 + Object a12) throws Throwable {
14.1876 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.1877 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1878 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.1879 + Object a4, Object a5, Object a6, Object a7,
14.1880 + Object a8, Object a9, Object a10, Object a11,
14.1881 + Object a12) throws Throwable {
14.1882 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.1883 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1884 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.1885 + Object a4, Object a5, Object a6, Object a7,
14.1886 + Object a8, Object a9, Object a10, Object a11,
14.1887 + Object a12) throws Throwable {
14.1888 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.1889 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1890 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.1891 + Object a4, Object a5, Object a6, Object a7,
14.1892 + Object a8, Object a9, Object a10, Object a11,
14.1893 + Object a12) throws Throwable {
14.1894 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.1895 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1896 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.1897 + Object a4, Object a5, Object a6, Object a7,
14.1898 + Object a8, Object a9, Object a10, Object a11,
14.1899 + Object a12) throws Throwable {
14.1900 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1901 + a10),
14.1902 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1903 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.1904 + Object a4, Object a5, Object a6, Object a7,
14.1905 + Object a8, Object a9, Object a10, Object a11,
14.1906 + Object a12) throws Throwable {
14.1907 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1908 + a10, a11),
14.1909 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1910 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.1911 + Object a4, Object a5, Object a6, Object a7,
14.1912 + Object a8, Object a9, Object a10, Object a11,
14.1913 + Object a12) throws Throwable {
14.1914 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12),
14.1915 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
14.1916 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.1917 + Object a4, Object a5, Object a6, Object a7,
14.1918 + Object a8, Object a9, Object a10, Object a11,
14.1919 + Object a12) throws Throwable {
14.1920 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1921 + a10, a11, a12)); }
14.1922 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.1923 + Object a4, Object a5, Object a6, Object a7,
14.1924 + Object a8, Object a9, Object a10, Object a11,
14.1925 + Object a12) throws Throwable {
14.1926 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1927 + a10, a11, a12)); }
14.1928 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.1929 + Object a4, Object a5, Object a6, Object a7,
14.1930 + Object a8, Object a9, Object a10, Object a11,
14.1931 + Object a12) throws Throwable {
14.1932 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.1933 + a10, a11, a12)); }
14.1934 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.1935 + Object a4, Object a5, Object a6, Object a7,
14.1936 + Object a8, Object a9, Object a10, Object a11,
14.1937 + Object a12) throws Throwable {
14.1938 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.1939 + a10, a11, a12)); }
14.1940 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.1941 + Object a4, Object a5, Object a6, Object a7,
14.1942 + Object a8, Object a9, Object a10, Object a11,
14.1943 + Object a12) throws Throwable {
14.1944 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.1945 + a10, a11, a12)); }
14.1946 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.1947 + Object a4, Object a5, Object a6, Object a7,
14.1948 + Object a8, Object a9, Object a10, Object a11,
14.1949 + Object a12) throws Throwable {
14.1950 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.1951 + a10, a11, a12)); }
14.1952 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.1953 + Object a4, Object a5, Object a6, Object a7,
14.1954 + Object a8, Object a9, Object a10, Object a11,
14.1955 + Object a12) throws Throwable {
14.1956 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.1957 + a10, a11, a12)); }
14.1958 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.1959 + Object a4, Object a5, Object a6, Object a7,
14.1960 + Object a8, Object a9, Object a10, Object a11,
14.1961 + Object a12) throws Throwable {
14.1962 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.1963 + a10, a11, a12)); }
14.1964 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.1965 + Object a4, Object a5, Object a6, Object a7,
14.1966 + Object a8, Object a9, Object a10, Object a11,
14.1967 + Object a12) throws Throwable {
14.1968 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.1969 + a10, a11, a12)); }
14.1970 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.1971 + Object a4, Object a5, Object a6, Object a7,
14.1972 + Object a8, Object a9, Object a10, Object a11,
14.1973 + Object a12) throws Throwable {
14.1974 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.1975 + a10, a11, a12)); }
14.1976 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.1977 + Object a4, Object a5, Object a6, Object a7,
14.1978 + Object a8, Object a9, Object a10, Object a11,
14.1979 + Object a12) throws Throwable {
14.1980 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12)); }
14.1981 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.1982 + Object a4, Object a5, Object a6, Object a7,
14.1983 + Object a8, Object a9, Object a10, Object a11,
14.1984 + Object a12) throws Throwable {
14.1985 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1986 + a10, filter.invoke(a11, a12)); }
14.1987 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.1988 + Object a4, Object a5, Object a6, Object a7,
14.1989 + Object a8, Object a9, Object a10, Object a11,
14.1990 + Object a12) throws Throwable {
14.1991 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.1992 + a10, a11, filter.invoke(a12)); }
14.1993 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.1994 + Object a4, Object a5, Object a6, Object a7,
14.1995 + Object a8, Object a9, Object a10, Object a11,
14.1996 + Object a12) throws Throwable {
14.1997 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, filter.invoke()); }
14.1998 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.1999 + Object a4, Object a5, Object a6, Object a7,
14.2000 + Object a8, Object a9, Object a10, Object a11,
14.2001 + Object a12) throws Throwable {
14.2002 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 };
14.2003 + filter.<void>invoke(av); // make the flyby
14.2004 + return target.invoke(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]); }
14.2005 + }
14.2006 + static class F14 extends Adapter {
14.2007 + protected F14(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.2008 + protected F14(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2009 + super(e, f, t); }
14.2010 + protected F14 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2011 + return new F14(e, f, t); }
14.2012 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.2013 + Object a4, Object a5, Object a6, Object a7,
14.2014 + Object a8, Object a9, Object a10, Object a11,
14.2015 + Object a12, Object a13) throws Throwable {
14.2016 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2017 + a10, a11, a12, a13); }
14.2018 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.2019 + Object a4, Object a5, Object a6, Object a7,
14.2020 + Object a8, Object a9, Object a10, Object a11,
14.2021 + Object a12, Object a13) throws Throwable {
14.2022 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.2023 + a10, a11, a12, a13); }
14.2024 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.2025 + Object a4, Object a5, Object a6, Object a7,
14.2026 + Object a8, Object a9, Object a10, Object a11,
14.2027 + Object a12, Object a13) throws Throwable {
14.2028 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.2029 + a10, a11, a12, a13); }
14.2030 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.2031 + Object a4, Object a5, Object a6, Object a7,
14.2032 + Object a8, Object a9, Object a10, Object a11,
14.2033 + Object a12, Object a13) throws Throwable {
14.2034 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.2035 + a10, a11, a12, a13); }
14.2036 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.2037 + Object a4, Object a5, Object a6, Object a7,
14.2038 + Object a8, Object a9, Object a10, Object a11,
14.2039 + Object a12, Object a13) throws Throwable {
14.2040 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.2041 + a10, a11, a12, a13); }
14.2042 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.2043 + Object a4, Object a5, Object a6, Object a7,
14.2044 + Object a8, Object a9, Object a10, Object a11,
14.2045 + Object a12, Object a13) throws Throwable {
14.2046 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.2047 + a10, a11, a12, a13); }
14.2048 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.2049 + Object a4, Object a5, Object a6, Object a7,
14.2050 + Object a8, Object a9, Object a10, Object a11,
14.2051 + Object a12, Object a13) throws Throwable {
14.2052 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.2053 + a10, a11, a12, a13); }
14.2054 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.2055 + Object a4, Object a5, Object a6, Object a7,
14.2056 + Object a8, Object a9, Object a10, Object a11,
14.2057 + Object a12, Object a13) throws Throwable {
14.2058 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.2059 + a10, a11, a12, a13); }
14.2060 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.2061 + Object a4, Object a5, Object a6, Object a7,
14.2062 + Object a8, Object a9, Object a10, Object a11,
14.2063 + Object a12, Object a13) throws Throwable {
14.2064 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.2065 + a10, a11, a12, a13); }
14.2066 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.2067 + Object a4, Object a5, Object a6, Object a7,
14.2068 + Object a8, Object a9, Object a10, Object a11,
14.2069 + Object a12, Object a13) throws Throwable {
14.2070 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.2071 + a10, a11, a12, a13); }
14.2072 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.2073 + Object a4, Object a5, Object a6, Object a7,
14.2074 + Object a8, Object a9, Object a10, Object a11,
14.2075 + Object a12, Object a13) throws Throwable {
14.2076 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2077 + filter.invoke(a10), a11, a12, a13); }
14.2078 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.2079 + Object a4, Object a5, Object a6, Object a7,
14.2080 + Object a8, Object a9, Object a10, Object a11,
14.2081 + Object a12, Object a13) throws Throwable {
14.2082 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2083 + a10, filter.invoke(a11), a12, a13); }
14.2084 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.2085 + Object a4, Object a5, Object a6, Object a7,
14.2086 + Object a8, Object a9, Object a10, Object a11,
14.2087 + Object a12, Object a13) throws Throwable {
14.2088 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2089 + a10, a11, filter.invoke(a12), a13); }
14.2090 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.2091 + Object a4, Object a5, Object a6, Object a7,
14.2092 + Object a8, Object a9, Object a10, Object a11,
14.2093 + Object a12, Object a13) throws Throwable {
14.2094 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2095 + a10, a11, a12, filter.invoke(a13)); }
14.2096 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.2097 + Object a4, Object a5, Object a6, Object a7,
14.2098 + Object a8, Object a9, Object a10, Object a11,
14.2099 + Object a12, Object a13) throws Throwable {
14.2100 + return target.invoke(filter.invoke(),
14.2101 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2102 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.2103 + Object a4, Object a5, Object a6, Object a7,
14.2104 + Object a8, Object a9, Object a10, Object a11,
14.2105 + Object a12, Object a13) throws Throwable {
14.2106 + return target.invoke(filter.invoke(a0),
14.2107 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2108 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.2109 + Object a4, Object a5, Object a6, Object a7,
14.2110 + Object a8, Object a9, Object a10, Object a11,
14.2111 + Object a12, Object a13) throws Throwable {
14.2112 + return target.invoke(filter.invoke(a0, a1),
14.2113 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2114 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.2115 + Object a4, Object a5, Object a6, Object a7,
14.2116 + Object a8, Object a9, Object a10, Object a11,
14.2117 + Object a12, Object a13) throws Throwable {
14.2118 + return target.invoke(filter.invoke(a0, a1, a2),
14.2119 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2120 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.2121 + Object a4, Object a5, Object a6, Object a7,
14.2122 + Object a8, Object a9, Object a10, Object a11,
14.2123 + Object a12, Object a13) throws Throwable {
14.2124 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.2125 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2126 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.2127 + Object a4, Object a5, Object a6, Object a7,
14.2128 + Object a8, Object a9, Object a10, Object a11,
14.2129 + Object a12, Object a13) throws Throwable {
14.2130 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.2131 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2132 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.2133 + Object a4, Object a5, Object a6, Object a7,
14.2134 + Object a8, Object a9, Object a10, Object a11,
14.2135 + Object a12, Object a13) throws Throwable {
14.2136 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.2137 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2138 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.2139 + Object a4, Object a5, Object a6, Object a7,
14.2140 + Object a8, Object a9, Object a10, Object a11,
14.2141 + Object a12, Object a13) throws Throwable {
14.2142 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.2143 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2144 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.2145 + Object a4, Object a5, Object a6, Object a7,
14.2146 + Object a8, Object a9, Object a10, Object a11,
14.2147 + Object a12, Object a13) throws Throwable {
14.2148 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.2149 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2150 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.2151 + Object a4, Object a5, Object a6, Object a7,
14.2152 + Object a8, Object a9, Object a10, Object a11,
14.2153 + Object a12, Object a13) throws Throwable {
14.2154 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.2155 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2156 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.2157 + Object a4, Object a5, Object a6, Object a7,
14.2158 + Object a8, Object a9, Object a10, Object a11,
14.2159 + Object a12, Object a13) throws Throwable {
14.2160 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.2161 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2162 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.2163 + Object a4, Object a5, Object a6, Object a7,
14.2164 + Object a8, Object a9, Object a10, Object a11,
14.2165 + Object a12, Object a13) throws Throwable {
14.2166 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2167 + a10),
14.2168 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2169 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.2170 + Object a4, Object a5, Object a6, Object a7,
14.2171 + Object a8, Object a9, Object a10, Object a11,
14.2172 + Object a12, Object a13) throws Throwable {
14.2173 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2174 + a10, a11),
14.2175 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2176 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.2177 + Object a4, Object a5, Object a6, Object a7,
14.2178 + Object a8, Object a9, Object a10, Object a11,
14.2179 + Object a12, Object a13) throws Throwable {
14.2180 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2181 + a10, a11, a12),
14.2182 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2183 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.2184 + Object a4, Object a5, Object a6, Object a7,
14.2185 + Object a8, Object a9, Object a10, Object a11,
14.2186 + Object a12, Object a13) throws Throwable {
14.2187 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13),
14.2188 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
14.2189 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.2190 + Object a4, Object a5, Object a6, Object a7,
14.2191 + Object a8, Object a9, Object a10, Object a11,
14.2192 + Object a12, Object a13) throws Throwable {
14.2193 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2194 + a10, a11, a12, a13)); }
14.2195 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.2196 + Object a4, Object a5, Object a6, Object a7,
14.2197 + Object a8, Object a9, Object a10, Object a11,
14.2198 + Object a12, Object a13) throws Throwable {
14.2199 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2200 + a10, a11, a12, a13)); }
14.2201 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.2202 + Object a4, Object a5, Object a6, Object a7,
14.2203 + Object a8, Object a9, Object a10, Object a11,
14.2204 + Object a12, Object a13) throws Throwable {
14.2205 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.2206 + a10, a11, a12, a13)); }
14.2207 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.2208 + Object a4, Object a5, Object a6, Object a7,
14.2209 + Object a8, Object a9, Object a10, Object a11,
14.2210 + Object a12, Object a13) throws Throwable {
14.2211 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.2212 + a10, a11, a12, a13)); }
14.2213 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.2214 + Object a4, Object a5, Object a6, Object a7,
14.2215 + Object a8, Object a9, Object a10, Object a11,
14.2216 + Object a12, Object a13) throws Throwable {
14.2217 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.2218 + a10, a11, a12, a13)); }
14.2219 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.2220 + Object a4, Object a5, Object a6, Object a7,
14.2221 + Object a8, Object a9, Object a10, Object a11,
14.2222 + Object a12, Object a13) throws Throwable {
14.2223 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.2224 + a10, a11, a12, a13)); }
14.2225 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.2226 + Object a4, Object a5, Object a6, Object a7,
14.2227 + Object a8, Object a9, Object a10, Object a11,
14.2228 + Object a12, Object a13) throws Throwable {
14.2229 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.2230 + a10, a11, a12, a13)); }
14.2231 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.2232 + Object a4, Object a5, Object a6, Object a7,
14.2233 + Object a8, Object a9, Object a10, Object a11,
14.2234 + Object a12, Object a13) throws Throwable {
14.2235 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.2236 + a10, a11, a12, a13)); }
14.2237 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.2238 + Object a4, Object a5, Object a6, Object a7,
14.2239 + Object a8, Object a9, Object a10, Object a11,
14.2240 + Object a12, Object a13) throws Throwable {
14.2241 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.2242 + a10, a11, a12, a13)); }
14.2243 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.2244 + Object a4, Object a5, Object a6, Object a7,
14.2245 + Object a8, Object a9, Object a10, Object a11,
14.2246 + Object a12, Object a13) throws Throwable {
14.2247 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.2248 + a10, a11, a12, a13)); }
14.2249 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.2250 + Object a4, Object a5, Object a6, Object a7,
14.2251 + Object a8, Object a9, Object a10, Object a11,
14.2252 + Object a12, Object a13) throws Throwable {
14.2253 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13)); }
14.2254 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.2255 + Object a4, Object a5, Object a6, Object a7,
14.2256 + Object a8, Object a9, Object a10, Object a11,
14.2257 + Object a12, Object a13) throws Throwable {
14.2258 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2259 + a10, filter.invoke(a11, a12, a13)); }
14.2260 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.2261 + Object a4, Object a5, Object a6, Object a7,
14.2262 + Object a8, Object a9, Object a10, Object a11,
14.2263 + Object a12, Object a13) throws Throwable {
14.2264 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2265 + a10, a11, filter.invoke(a12, a13)); }
14.2266 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.2267 + Object a4, Object a5, Object a6, Object a7,
14.2268 + Object a8, Object a9, Object a10, Object a11,
14.2269 + Object a12, Object a13) throws Throwable {
14.2270 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2271 + a10, a11, a12, filter.invoke(a13)); }
14.2272 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.2273 + Object a4, Object a5, Object a6, Object a7,
14.2274 + Object a8, Object a9, Object a10, Object a11,
14.2275 + Object a12, Object a13) throws Throwable {
14.2276 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, filter.invoke()); }
14.2277 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.2278 + Object a4, Object a5, Object a6, Object a7,
14.2279 + Object a8, Object a9, Object a10, Object a11,
14.2280 + Object a12, Object a13) throws Throwable {
14.2281 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13 };
14.2282 + filter.<void>invoke(av); // make the flyby
14.2283 + return target.invoke(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]); }
14.2284 + }
14.2285 + static class F15 extends Adapter {
14.2286 + protected F15(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.2287 + protected F15(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2288 + super(e, f, t); }
14.2289 + protected F15 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2290 + return new F15(e, f, t); }
14.2291 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.2292 + Object a4, Object a5, Object a6, Object a7,
14.2293 + Object a8, Object a9, Object a10, Object a11,
14.2294 + Object a12, Object a13, Object a14) throws Throwable {
14.2295 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2296 + a10, a11, a12, a13, a14); }
14.2297 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.2298 + Object a4, Object a5, Object a6, Object a7,
14.2299 + Object a8, Object a9, Object a10, Object a11,
14.2300 + Object a12, Object a13, Object a14) throws Throwable {
14.2301 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.2302 + a10, a11, a12, a13, a14); }
14.2303 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.2304 + Object a4, Object a5, Object a6, Object a7,
14.2305 + Object a8, Object a9, Object a10, Object a11,
14.2306 + Object a12, Object a13, Object a14) throws Throwable {
14.2307 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.2308 + a10, a11, a12, a13, a14); }
14.2309 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.2310 + Object a4, Object a5, Object a6, Object a7,
14.2311 + Object a8, Object a9, Object a10, Object a11,
14.2312 + Object a12, Object a13, Object a14) throws Throwable {
14.2313 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.2314 + a10, a11, a12, a13, a14); }
14.2315 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.2316 + Object a4, Object a5, Object a6, Object a7,
14.2317 + Object a8, Object a9, Object a10, Object a11,
14.2318 + Object a12, Object a13, Object a14) throws Throwable {
14.2319 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.2320 + a10, a11, a12, a13, a14); }
14.2321 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.2322 + Object a4, Object a5, Object a6, Object a7,
14.2323 + Object a8, Object a9, Object a10, Object a11,
14.2324 + Object a12, Object a13, Object a14) throws Throwable {
14.2325 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.2326 + a10, a11, a12, a13, a14); }
14.2327 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.2328 + Object a4, Object a5, Object a6, Object a7,
14.2329 + Object a8, Object a9, Object a10, Object a11,
14.2330 + Object a12, Object a13, Object a14) throws Throwable {
14.2331 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.2332 + a10, a11, a12, a13, a14); }
14.2333 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.2334 + Object a4, Object a5, Object a6, Object a7,
14.2335 + Object a8, Object a9, Object a10, Object a11,
14.2336 + Object a12, Object a13, Object a14) throws Throwable {
14.2337 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.2338 + a10, a11, a12, a13, a14); }
14.2339 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.2340 + Object a4, Object a5, Object a6, Object a7,
14.2341 + Object a8, Object a9, Object a10, Object a11,
14.2342 + Object a12, Object a13, Object a14) throws Throwable {
14.2343 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.2344 + a10, a11, a12, a13, a14); }
14.2345 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.2346 + Object a4, Object a5, Object a6, Object a7,
14.2347 + Object a8, Object a9, Object a10, Object a11,
14.2348 + Object a12, Object a13, Object a14) throws Throwable {
14.2349 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.2350 + a10, a11, a12, a13, a14); }
14.2351 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.2352 + Object a4, Object a5, Object a6, Object a7,
14.2353 + Object a8, Object a9, Object a10, Object a11,
14.2354 + Object a12, Object a13, Object a14) throws Throwable {
14.2355 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2356 + filter.invoke(a10), a11, a12, a13, a14); }
14.2357 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.2358 + Object a4, Object a5, Object a6, Object a7,
14.2359 + Object a8, Object a9, Object a10, Object a11,
14.2360 + Object a12, Object a13, Object a14) throws Throwable {
14.2361 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2362 + a10, filter.invoke(a11), a12, a13, a14); }
14.2363 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.2364 + Object a4, Object a5, Object a6, Object a7,
14.2365 + Object a8, Object a9, Object a10, Object a11,
14.2366 + Object a12, Object a13, Object a14) throws Throwable {
14.2367 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2368 + a10, a11, filter.invoke(a12), a13, a14); }
14.2369 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.2370 + Object a4, Object a5, Object a6, Object a7,
14.2371 + Object a8, Object a9, Object a10, Object a11,
14.2372 + Object a12, Object a13, Object a14) throws Throwable {
14.2373 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2374 + a10, a11, a12, filter.invoke(a13), a14); }
14.2375 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.2376 + Object a4, Object a5, Object a6, Object a7,
14.2377 + Object a8, Object a9, Object a10, Object a11,
14.2378 + Object a12, Object a13, Object a14) throws Throwable {
14.2379 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2380 + a10, a11, a12, a13, filter.invoke(a14)); }
14.2381 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.2382 + Object a4, Object a5, Object a6, Object a7,
14.2383 + Object a8, Object a9, Object a10, Object a11,
14.2384 + Object a12, Object a13, Object a14) throws Throwable {
14.2385 + return target.invoke(filter.invoke(),
14.2386 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2387 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.2388 + Object a4, Object a5, Object a6, Object a7,
14.2389 + Object a8, Object a9, Object a10, Object a11,
14.2390 + Object a12, Object a13, Object a14) throws Throwable {
14.2391 + return target.invoke(filter.invoke(a0),
14.2392 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2393 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.2394 + Object a4, Object a5, Object a6, Object a7,
14.2395 + Object a8, Object a9, Object a10, Object a11,
14.2396 + Object a12, Object a13, Object a14) throws Throwable {
14.2397 + return target.invoke(filter.invoke(a0, a1),
14.2398 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2399 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.2400 + Object a4, Object a5, Object a6, Object a7,
14.2401 + Object a8, Object a9, Object a10, Object a11,
14.2402 + Object a12, Object a13, Object a14) throws Throwable {
14.2403 + return target.invoke(filter.invoke(a0, a1, a2),
14.2404 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2405 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.2406 + Object a4, Object a5, Object a6, Object a7,
14.2407 + Object a8, Object a9, Object a10, Object a11,
14.2408 + Object a12, Object a13, Object a14) throws Throwable {
14.2409 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.2410 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2411 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.2412 + Object a4, Object a5, Object a6, Object a7,
14.2413 + Object a8, Object a9, Object a10, Object a11,
14.2414 + Object a12, Object a13, Object a14) throws Throwable {
14.2415 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.2416 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2417 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.2418 + Object a4, Object a5, Object a6, Object a7,
14.2419 + Object a8, Object a9, Object a10, Object a11,
14.2420 + Object a12, Object a13, Object a14) throws Throwable {
14.2421 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.2422 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2423 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.2424 + Object a4, Object a5, Object a6, Object a7,
14.2425 + Object a8, Object a9, Object a10, Object a11,
14.2426 + Object a12, Object a13, Object a14) throws Throwable {
14.2427 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.2428 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2429 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.2430 + Object a4, Object a5, Object a6, Object a7,
14.2431 + Object a8, Object a9, Object a10, Object a11,
14.2432 + Object a12, Object a13, Object a14) throws Throwable {
14.2433 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.2434 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2435 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.2436 + Object a4, Object a5, Object a6, Object a7,
14.2437 + Object a8, Object a9, Object a10, Object a11,
14.2438 + Object a12, Object a13, Object a14) throws Throwable {
14.2439 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.2440 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2441 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.2442 + Object a4, Object a5, Object a6, Object a7,
14.2443 + Object a8, Object a9, Object a10, Object a11,
14.2444 + Object a12, Object a13, Object a14) throws Throwable {
14.2445 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.2446 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2447 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.2448 + Object a4, Object a5, Object a6, Object a7,
14.2449 + Object a8, Object a9, Object a10, Object a11,
14.2450 + Object a12, Object a13, Object a14) throws Throwable {
14.2451 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2452 + a10),
14.2453 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2454 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.2455 + Object a4, Object a5, Object a6, Object a7,
14.2456 + Object a8, Object a9, Object a10, Object a11,
14.2457 + Object a12, Object a13, Object a14) throws Throwable {
14.2458 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2459 + a10, a11),
14.2460 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2461 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.2462 + Object a4, Object a5, Object a6, Object a7,
14.2463 + Object a8, Object a9, Object a10, Object a11,
14.2464 + Object a12, Object a13, Object a14) throws Throwable {
14.2465 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2466 + a10, a11, a12),
14.2467 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2468 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.2469 + Object a4, Object a5, Object a6, Object a7,
14.2470 + Object a8, Object a9, Object a10, Object a11,
14.2471 + Object a12, Object a13, Object a14) throws Throwable {
14.2472 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2473 + a10, a11, a12, a13),
14.2474 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2475 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.2476 + Object a4, Object a5, Object a6, Object a7,
14.2477 + Object a8, Object a9, Object a10, Object a11,
14.2478 + Object a12, Object a13, Object a14) throws Throwable {
14.2479 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14),
14.2480 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
14.2481 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.2482 + Object a4, Object a5, Object a6, Object a7,
14.2483 + Object a8, Object a9, Object a10, Object a11,
14.2484 + Object a12, Object a13, Object a14) throws Throwable {
14.2485 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2486 + a10, a11, a12, a13, a14)); }
14.2487 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.2488 + Object a4, Object a5, Object a6, Object a7,
14.2489 + Object a8, Object a9, Object a10, Object a11,
14.2490 + Object a12, Object a13, Object a14) throws Throwable {
14.2491 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2492 + a10, a11, a12, a13, a14)); }
14.2493 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.2494 + Object a4, Object a5, Object a6, Object a7,
14.2495 + Object a8, Object a9, Object a10, Object a11,
14.2496 + Object a12, Object a13, Object a14) throws Throwable {
14.2497 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.2498 + a10, a11, a12, a13, a14)); }
14.2499 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.2500 + Object a4, Object a5, Object a6, Object a7,
14.2501 + Object a8, Object a9, Object a10, Object a11,
14.2502 + Object a12, Object a13, Object a14) throws Throwable {
14.2503 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.2504 + a10, a11, a12, a13, a14)); }
14.2505 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.2506 + Object a4, Object a5, Object a6, Object a7,
14.2507 + Object a8, Object a9, Object a10, Object a11,
14.2508 + Object a12, Object a13, Object a14) throws Throwable {
14.2509 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.2510 + a10, a11, a12, a13, a14)); }
14.2511 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.2512 + Object a4, Object a5, Object a6, Object a7,
14.2513 + Object a8, Object a9, Object a10, Object a11,
14.2514 + Object a12, Object a13, Object a14) throws Throwable {
14.2515 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.2516 + a10, a11, a12, a13, a14)); }
14.2517 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.2518 + Object a4, Object a5, Object a6, Object a7,
14.2519 + Object a8, Object a9, Object a10, Object a11,
14.2520 + Object a12, Object a13, Object a14) throws Throwable {
14.2521 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.2522 + a10, a11, a12, a13, a14)); }
14.2523 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.2524 + Object a4, Object a5, Object a6, Object a7,
14.2525 + Object a8, Object a9, Object a10, Object a11,
14.2526 + Object a12, Object a13, Object a14) throws Throwable {
14.2527 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.2528 + a10, a11, a12, a13, a14)); }
14.2529 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.2530 + Object a4, Object a5, Object a6, Object a7,
14.2531 + Object a8, Object a9, Object a10, Object a11,
14.2532 + Object a12, Object a13, Object a14) throws Throwable {
14.2533 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.2534 + a10, a11, a12, a13, a14)); }
14.2535 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.2536 + Object a4, Object a5, Object a6, Object a7,
14.2537 + Object a8, Object a9, Object a10, Object a11,
14.2538 + Object a12, Object a13, Object a14) throws Throwable {
14.2539 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.2540 + a10, a11, a12, a13, a14)); }
14.2541 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.2542 + Object a4, Object a5, Object a6, Object a7,
14.2543 + Object a8, Object a9, Object a10, Object a11,
14.2544 + Object a12, Object a13, Object a14) throws Throwable {
14.2545 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14)); }
14.2546 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.2547 + Object a4, Object a5, Object a6, Object a7,
14.2548 + Object a8, Object a9, Object a10, Object a11,
14.2549 + Object a12, Object a13, Object a14) throws Throwable {
14.2550 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2551 + a10, filter.invoke(a11, a12, a13, a14)); }
14.2552 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.2553 + Object a4, Object a5, Object a6, Object a7,
14.2554 + Object a8, Object a9, Object a10, Object a11,
14.2555 + Object a12, Object a13, Object a14) throws Throwable {
14.2556 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2557 + a10, a11, filter.invoke(a12, a13, a14)); }
14.2558 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.2559 + Object a4, Object a5, Object a6, Object a7,
14.2560 + Object a8, Object a9, Object a10, Object a11,
14.2561 + Object a12, Object a13, Object a14) throws Throwable {
14.2562 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2563 + a10, a11, a12, filter.invoke(a13, a14)); }
14.2564 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.2565 + Object a4, Object a5, Object a6, Object a7,
14.2566 + Object a8, Object a9, Object a10, Object a11,
14.2567 + Object a12, Object a13, Object a14) throws Throwable {
14.2568 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2569 + a10, a11, a12, a13, filter.invoke(a14)); }
14.2570 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.2571 + Object a4, Object a5, Object a6, Object a7,
14.2572 + Object a8, Object a9, Object a10, Object a11,
14.2573 + Object a12, Object a13, Object a14) throws Throwable {
14.2574 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, filter.invoke()); }
14.2575 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.2576 + Object a4, Object a5, Object a6, Object a7,
14.2577 + Object a8, Object a9, Object a10, Object a11,
14.2578 + Object a12, Object a13, Object a14) throws Throwable {
14.2579 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14 };
14.2580 + filter.<void>invoke(av); // make the flyby
14.2581 + return target.invoke(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]); }
14.2582 + }
14.2583 + static class F16 extends Adapter {
14.2584 + protected F16(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.2585 + protected F16(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2586 + super(e, f, t); }
14.2587 + protected F16 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2588 + return new F16(e, f, t); }
14.2589 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.2590 + Object a4, Object a5, Object a6, Object a7,
14.2591 + Object a8, Object a9, Object a10, Object a11,
14.2592 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2593 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2594 + a10, a11, a12, a13, a14, a15); }
14.2595 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.2596 + Object a4, Object a5, Object a6, Object a7,
14.2597 + Object a8, Object a9, Object a10, Object a11,
14.2598 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2599 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.2600 + a10, a11, a12, a13, a14, a15); }
14.2601 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.2602 + Object a4, Object a5, Object a6, Object a7,
14.2603 + Object a8, Object a9, Object a10, Object a11,
14.2604 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2605 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.2606 + a10, a11, a12, a13, a14, a15); }
14.2607 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.2608 + Object a4, Object a5, Object a6, Object a7,
14.2609 + Object a8, Object a9, Object a10, Object a11,
14.2610 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2611 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.2612 + a10, a11, a12, a13, a14, a15); }
14.2613 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.2614 + Object a4, Object a5, Object a6, Object a7,
14.2615 + Object a8, Object a9, Object a10, Object a11,
14.2616 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2617 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.2618 + a10, a11, a12, a13, a14, a15); }
14.2619 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.2620 + Object a4, Object a5, Object a6, Object a7,
14.2621 + Object a8, Object a9, Object a10, Object a11,
14.2622 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2623 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.2624 + a10, a11, a12, a13, a14, a15); }
14.2625 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.2626 + Object a4, Object a5, Object a6, Object a7,
14.2627 + Object a8, Object a9, Object a10, Object a11,
14.2628 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2629 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.2630 + a10, a11, a12, a13, a14, a15); }
14.2631 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.2632 + Object a4, Object a5, Object a6, Object a7,
14.2633 + Object a8, Object a9, Object a10, Object a11,
14.2634 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2635 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.2636 + a10, a11, a12, a13, a14, a15); }
14.2637 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.2638 + Object a4, Object a5, Object a6, Object a7,
14.2639 + Object a8, Object a9, Object a10, Object a11,
14.2640 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2641 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.2642 + a10, a11, a12, a13, a14, a15); }
14.2643 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.2644 + Object a4, Object a5, Object a6, Object a7,
14.2645 + Object a8, Object a9, Object a10, Object a11,
14.2646 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2647 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.2648 + a10, a11, a12, a13, a14, a15); }
14.2649 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.2650 + Object a4, Object a5, Object a6, Object a7,
14.2651 + Object a8, Object a9, Object a10, Object a11,
14.2652 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2653 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2654 + filter.invoke(a10), a11, a12, a13, a14, a15); }
14.2655 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.2656 + Object a4, Object a5, Object a6, Object a7,
14.2657 + Object a8, Object a9, Object a10, Object a11,
14.2658 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2659 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2660 + a10, filter.invoke(a11), a12, a13, a14, a15); }
14.2661 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.2662 + Object a4, Object a5, Object a6, Object a7,
14.2663 + Object a8, Object a9, Object a10, Object a11,
14.2664 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2665 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2666 + a10, a11, filter.invoke(a12), a13, a14, a15); }
14.2667 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.2668 + Object a4, Object a5, Object a6, Object a7,
14.2669 + Object a8, Object a9, Object a10, Object a11,
14.2670 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2671 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2672 + a10, a11, a12, filter.invoke(a13), a14, a15); }
14.2673 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.2674 + Object a4, Object a5, Object a6, Object a7,
14.2675 + Object a8, Object a9, Object a10, Object a11,
14.2676 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2677 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2678 + a10, a11, a12, a13, filter.invoke(a14), a15); }
14.2679 + protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
14.2680 + Object a4, Object a5, Object a6, Object a7,
14.2681 + Object a8, Object a9, Object a10, Object a11,
14.2682 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2683 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2684 + a10, a11, a12, a13, a14, filter.invoke(a15)); }
14.2685 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.2686 + Object a4, Object a5, Object a6, Object a7,
14.2687 + Object a8, Object a9, Object a10, Object a11,
14.2688 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2689 + return target.invoke(filter.invoke(),
14.2690 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2691 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.2692 + Object a4, Object a5, Object a6, Object a7,
14.2693 + Object a8, Object a9, Object a10, Object a11,
14.2694 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2695 + return target.invoke(filter.invoke(a0),
14.2696 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2697 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.2698 + Object a4, Object a5, Object a6, Object a7,
14.2699 + Object a8, Object a9, Object a10, Object a11,
14.2700 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2701 + return target.invoke(filter.invoke(a0, a1),
14.2702 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2703 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.2704 + Object a4, Object a5, Object a6, Object a7,
14.2705 + Object a8, Object a9, Object a10, Object a11,
14.2706 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2707 + return target.invoke(filter.invoke(a0, a1, a2),
14.2708 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2709 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.2710 + Object a4, Object a5, Object a6, Object a7,
14.2711 + Object a8, Object a9, Object a10, Object a11,
14.2712 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2713 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.2714 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2715 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.2716 + Object a4, Object a5, Object a6, Object a7,
14.2717 + Object a8, Object a9, Object a10, Object a11,
14.2718 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2719 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.2720 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2721 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.2722 + Object a4, Object a5, Object a6, Object a7,
14.2723 + Object a8, Object a9, Object a10, Object a11,
14.2724 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2725 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.2726 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2727 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.2728 + Object a4, Object a5, Object a6, Object a7,
14.2729 + Object a8, Object a9, Object a10, Object a11,
14.2730 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2731 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.2732 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2733 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.2734 + Object a4, Object a5, Object a6, Object a7,
14.2735 + Object a8, Object a9, Object a10, Object a11,
14.2736 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2737 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.2738 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2739 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.2740 + Object a4, Object a5, Object a6, Object a7,
14.2741 + Object a8, Object a9, Object a10, Object a11,
14.2742 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2743 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.2744 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2745 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.2746 + Object a4, Object a5, Object a6, Object a7,
14.2747 + Object a8, Object a9, Object a10, Object a11,
14.2748 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2749 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.2750 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2751 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.2752 + Object a4, Object a5, Object a6, Object a7,
14.2753 + Object a8, Object a9, Object a10, Object a11,
14.2754 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2755 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2756 + a10),
14.2757 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2758 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.2759 + Object a4, Object a5, Object a6, Object a7,
14.2760 + Object a8, Object a9, Object a10, Object a11,
14.2761 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2762 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2763 + a10, a11),
14.2764 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2765 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.2766 + Object a4, Object a5, Object a6, Object a7,
14.2767 + Object a8, Object a9, Object a10, Object a11,
14.2768 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2769 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2770 + a10, a11, a12),
14.2771 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2772 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.2773 + Object a4, Object a5, Object a6, Object a7,
14.2774 + Object a8, Object a9, Object a10, Object a11,
14.2775 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2776 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2777 + a10, a11, a12, a13),
14.2778 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2779 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.2780 + Object a4, Object a5, Object a6, Object a7,
14.2781 + Object a8, Object a9, Object a10, Object a11,
14.2782 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2783 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2784 + a10, a11, a12, a13, a14),
14.2785 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2786 + protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
14.2787 + Object a4, Object a5, Object a6, Object a7,
14.2788 + Object a8, Object a9, Object a10, Object a11,
14.2789 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2790 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15),
14.2791 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
14.2792 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.2793 + Object a4, Object a5, Object a6, Object a7,
14.2794 + Object a8, Object a9, Object a10, Object a11,
14.2795 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2796 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2797 + a10, a11, a12, a13, a14, a15)); }
14.2798 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.2799 + Object a4, Object a5, Object a6, Object a7,
14.2800 + Object a8, Object a9, Object a10, Object a11,
14.2801 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2802 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2803 + a10, a11, a12, a13, a14, a15)); }
14.2804 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.2805 + Object a4, Object a5, Object a6, Object a7,
14.2806 + Object a8, Object a9, Object a10, Object a11,
14.2807 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2808 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.2809 + a10, a11, a12, a13, a14, a15)); }
14.2810 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.2811 + Object a4, Object a5, Object a6, Object a7,
14.2812 + Object a8, Object a9, Object a10, Object a11,
14.2813 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2814 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.2815 + a10, a11, a12, a13, a14, a15)); }
14.2816 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.2817 + Object a4, Object a5, Object a6, Object a7,
14.2818 + Object a8, Object a9, Object a10, Object a11,
14.2819 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2820 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.2821 + a10, a11, a12, a13, a14, a15)); }
14.2822 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.2823 + Object a4, Object a5, Object a6, Object a7,
14.2824 + Object a8, Object a9, Object a10, Object a11,
14.2825 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2826 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.2827 + a10, a11, a12, a13, a14, a15)); }
14.2828 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.2829 + Object a4, Object a5, Object a6, Object a7,
14.2830 + Object a8, Object a9, Object a10, Object a11,
14.2831 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2832 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.2833 + a10, a11, a12, a13, a14, a15)); }
14.2834 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.2835 + Object a4, Object a5, Object a6, Object a7,
14.2836 + Object a8, Object a9, Object a10, Object a11,
14.2837 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2838 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.2839 + a10, a11, a12, a13, a14, a15)); }
14.2840 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.2841 + Object a4, Object a5, Object a6, Object a7,
14.2842 + Object a8, Object a9, Object a10, Object a11,
14.2843 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2844 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.2845 + a10, a11, a12, a13, a14, a15)); }
14.2846 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.2847 + Object a4, Object a5, Object a6, Object a7,
14.2848 + Object a8, Object a9, Object a10, Object a11,
14.2849 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2850 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.2851 + a10, a11, a12, a13, a14, a15)); }
14.2852 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.2853 + Object a4, Object a5, Object a6, Object a7,
14.2854 + Object a8, Object a9, Object a10, Object a11,
14.2855 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2856 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14, a15)); }
14.2857 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.2858 + Object a4, Object a5, Object a6, Object a7,
14.2859 + Object a8, Object a9, Object a10, Object a11,
14.2860 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2861 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2862 + a10, filter.invoke(a11, a12, a13, a14, a15)); }
14.2863 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.2864 + Object a4, Object a5, Object a6, Object a7,
14.2865 + Object a8, Object a9, Object a10, Object a11,
14.2866 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2867 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2868 + a10, a11, filter.invoke(a12, a13, a14, a15)); }
14.2869 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.2870 + Object a4, Object a5, Object a6, Object a7,
14.2871 + Object a8, Object a9, Object a10, Object a11,
14.2872 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2873 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2874 + a10, a11, a12, filter.invoke(a13, a14, a15)); }
14.2875 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.2876 + Object a4, Object a5, Object a6, Object a7,
14.2877 + Object a8, Object a9, Object a10, Object a11,
14.2878 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2879 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2880 + a10, a11, a12, a13, filter.invoke(a14, a15)); }
14.2881 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.2882 + Object a4, Object a5, Object a6, Object a7,
14.2883 + Object a8, Object a9, Object a10, Object a11,
14.2884 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2885 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2886 + a10, a11, a12, a13, a14, filter.invoke(a15)); }
14.2887 + protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
14.2888 + Object a4, Object a5, Object a6, Object a7,
14.2889 + Object a8, Object a9, Object a10, Object a11,
14.2890 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2891 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, filter.invoke()); }
14.2892 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.2893 + Object a4, Object a5, Object a6, Object a7,
14.2894 + Object a8, Object a9, Object a10, Object a11,
14.2895 + Object a12, Object a13, Object a14, Object a15) throws Throwable {
14.2896 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 };
14.2897 + filter.<void>invoke(av); // make the flyby
14.2898 + return target.invoke(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]); }
14.2899 + }
14.2900 + static class F17 extends Adapter {
14.2901 + protected F17(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.2902 + protected F17(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2903 + super(e, f, t); }
14.2904 + protected F17 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.2905 + return new F17(e, f, t); }
14.2906 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.2907 + Object a4, Object a5, Object a6, Object a7,
14.2908 + Object a8, Object a9, Object a10, Object a11,
14.2909 + Object a12, Object a13, Object a14, Object a15,
14.2910 + Object a16) throws Throwable {
14.2911 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2912 + a10, a11, a12, a13, a14, a15, a16); }
14.2913 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.2914 + Object a4, Object a5, Object a6, Object a7,
14.2915 + Object a8, Object a9, Object a10, Object a11,
14.2916 + Object a12, Object a13, Object a14, Object a15,
14.2917 + Object a16) throws Throwable {
14.2918 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.2919 + a10, a11, a12, a13, a14, a15, a16); }
14.2920 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.2921 + Object a4, Object a5, Object a6, Object a7,
14.2922 + Object a8, Object a9, Object a10, Object a11,
14.2923 + Object a12, Object a13, Object a14, Object a15,
14.2924 + Object a16) throws Throwable {
14.2925 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.2926 + a10, a11, a12, a13, a14, a15, a16); }
14.2927 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.2928 + Object a4, Object a5, Object a6, Object a7,
14.2929 + Object a8, Object a9, Object a10, Object a11,
14.2930 + Object a12, Object a13, Object a14, Object a15,
14.2931 + Object a16) throws Throwable {
14.2932 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.2933 + a10, a11, a12, a13, a14, a15, a16); }
14.2934 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.2935 + Object a4, Object a5, Object a6, Object a7,
14.2936 + Object a8, Object a9, Object a10, Object a11,
14.2937 + Object a12, Object a13, Object a14, Object a15,
14.2938 + Object a16) throws Throwable {
14.2939 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.2940 + a10, a11, a12, a13, a14, a15, a16); }
14.2941 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.2942 + Object a4, Object a5, Object a6, Object a7,
14.2943 + Object a8, Object a9, Object a10, Object a11,
14.2944 + Object a12, Object a13, Object a14, Object a15,
14.2945 + Object a16) throws Throwable {
14.2946 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.2947 + a10, a11, a12, a13, a14, a15, a16); }
14.2948 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.2949 + Object a4, Object a5, Object a6, Object a7,
14.2950 + Object a8, Object a9, Object a10, Object a11,
14.2951 + Object a12, Object a13, Object a14, Object a15,
14.2952 + Object a16) throws Throwable {
14.2953 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.2954 + a10, a11, a12, a13, a14, a15, a16); }
14.2955 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.2956 + Object a4, Object a5, Object a6, Object a7,
14.2957 + Object a8, Object a9, Object a10, Object a11,
14.2958 + Object a12, Object a13, Object a14, Object a15,
14.2959 + Object a16) throws Throwable {
14.2960 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.2961 + a10, a11, a12, a13, a14, a15, a16); }
14.2962 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.2963 + Object a4, Object a5, Object a6, Object a7,
14.2964 + Object a8, Object a9, Object a10, Object a11,
14.2965 + Object a12, Object a13, Object a14, Object a15,
14.2966 + Object a16) throws Throwable {
14.2967 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.2968 + a10, a11, a12, a13, a14, a15, a16); }
14.2969 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.2970 + Object a4, Object a5, Object a6, Object a7,
14.2971 + Object a8, Object a9, Object a10, Object a11,
14.2972 + Object a12, Object a13, Object a14, Object a15,
14.2973 + Object a16) throws Throwable {
14.2974 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.2975 + a10, a11, a12, a13, a14, a15, a16); }
14.2976 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.2977 + Object a4, Object a5, Object a6, Object a7,
14.2978 + Object a8, Object a9, Object a10, Object a11,
14.2979 + Object a12, Object a13, Object a14, Object a15,
14.2980 + Object a16) throws Throwable {
14.2981 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2982 + filter.invoke(a10), a11, a12, a13, a14, a15, a16); }
14.2983 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.2984 + Object a4, Object a5, Object a6, Object a7,
14.2985 + Object a8, Object a9, Object a10, Object a11,
14.2986 + Object a12, Object a13, Object a14, Object a15,
14.2987 + Object a16) throws Throwable {
14.2988 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2989 + a10, filter.invoke(a11), a12, a13, a14, a15, a16); }
14.2990 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.2991 + Object a4, Object a5, Object a6, Object a7,
14.2992 + Object a8, Object a9, Object a10, Object a11,
14.2993 + Object a12, Object a13, Object a14, Object a15,
14.2994 + Object a16) throws Throwable {
14.2995 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.2996 + a10, a11, filter.invoke(a12), a13, a14, a15, a16); }
14.2997 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.2998 + Object a4, Object a5, Object a6, Object a7,
14.2999 + Object a8, Object a9, Object a10, Object a11,
14.3000 + Object a12, Object a13, Object a14, Object a15,
14.3001 + Object a16) throws Throwable {
14.3002 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3003 + a10, a11, a12, filter.invoke(a13), a14, a15, a16); }
14.3004 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.3005 + Object a4, Object a5, Object a6, Object a7,
14.3006 + Object a8, Object a9, Object a10, Object a11,
14.3007 + Object a12, Object a13, Object a14, Object a15,
14.3008 + Object a16) throws Throwable {
14.3009 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3010 + a10, a11, a12, a13, filter.invoke(a14), a15, a16); }
14.3011 + protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
14.3012 + Object a4, Object a5, Object a6, Object a7,
14.3013 + Object a8, Object a9, Object a10, Object a11,
14.3014 + Object a12, Object a13, Object a14, Object a15,
14.3015 + Object a16) throws Throwable {
14.3016 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3017 + a10, a11, a12, a13, a14, filter.invoke(a15), a16); }
14.3018 + protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
14.3019 + Object a4, Object a5, Object a6, Object a7,
14.3020 + Object a8, Object a9, Object a10, Object a11,
14.3021 + Object a12, Object a13, Object a14, Object a15,
14.3022 + Object a16) throws Throwable {
14.3023 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3024 + a10, a11, a12, a13, a14, a15, filter.invoke(a16)); }
14.3025 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.3026 + Object a4, Object a5, Object a6, Object a7,
14.3027 + Object a8, Object a9, Object a10, Object a11,
14.3028 + Object a12, Object a13, Object a14, Object a15,
14.3029 + Object a16) throws Throwable {
14.3030 + return target.invoke(filter.invoke(),
14.3031 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3032 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.3033 + Object a4, Object a5, Object a6, Object a7,
14.3034 + Object a8, Object a9, Object a10, Object a11,
14.3035 + Object a12, Object a13, Object a14, Object a15,
14.3036 + Object a16) throws Throwable {
14.3037 + return target.invoke(filter.invoke(a0),
14.3038 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3039 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.3040 + Object a4, Object a5, Object a6, Object a7,
14.3041 + Object a8, Object a9, Object a10, Object a11,
14.3042 + Object a12, Object a13, Object a14, Object a15,
14.3043 + Object a16) throws Throwable {
14.3044 + return target.invoke(filter.invoke(a0, a1),
14.3045 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3046 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.3047 + Object a4, Object a5, Object a6, Object a7,
14.3048 + Object a8, Object a9, Object a10, Object a11,
14.3049 + Object a12, Object a13, Object a14, Object a15,
14.3050 + Object a16) throws Throwable {
14.3051 + return target.invoke(filter.invoke(a0, a1, a2),
14.3052 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3053 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.3054 + Object a4, Object a5, Object a6, Object a7,
14.3055 + Object a8, Object a9, Object a10, Object a11,
14.3056 + Object a12, Object a13, Object a14, Object a15,
14.3057 + Object a16) throws Throwable {
14.3058 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.3059 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3060 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.3061 + Object a4, Object a5, Object a6, Object a7,
14.3062 + Object a8, Object a9, Object a10, Object a11,
14.3063 + Object a12, Object a13, Object a14, Object a15,
14.3064 + Object a16) throws Throwable {
14.3065 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.3066 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3067 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.3068 + Object a4, Object a5, Object a6, Object a7,
14.3069 + Object a8, Object a9, Object a10, Object a11,
14.3070 + Object a12, Object a13, Object a14, Object a15,
14.3071 + Object a16) throws Throwable {
14.3072 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.3073 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3074 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.3075 + Object a4, Object a5, Object a6, Object a7,
14.3076 + Object a8, Object a9, Object a10, Object a11,
14.3077 + Object a12, Object a13, Object a14, Object a15,
14.3078 + Object a16) throws Throwable {
14.3079 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.3080 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3081 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.3082 + Object a4, Object a5, Object a6, Object a7,
14.3083 + Object a8, Object a9, Object a10, Object a11,
14.3084 + Object a12, Object a13, Object a14, Object a15,
14.3085 + Object a16) throws Throwable {
14.3086 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.3087 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3088 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.3089 + Object a4, Object a5, Object a6, Object a7,
14.3090 + Object a8, Object a9, Object a10, Object a11,
14.3091 + Object a12, Object a13, Object a14, Object a15,
14.3092 + Object a16) throws Throwable {
14.3093 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.3094 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3095 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.3096 + Object a4, Object a5, Object a6, Object a7,
14.3097 + Object a8, Object a9, Object a10, Object a11,
14.3098 + Object a12, Object a13, Object a14, Object a15,
14.3099 + Object a16) throws Throwable {
14.3100 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.3101 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3102 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.3103 + Object a4, Object a5, Object a6, Object a7,
14.3104 + Object a8, Object a9, Object a10, Object a11,
14.3105 + Object a12, Object a13, Object a14, Object a15,
14.3106 + Object a16) throws Throwable {
14.3107 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3108 + a10),
14.3109 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3110 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.3111 + Object a4, Object a5, Object a6, Object a7,
14.3112 + Object a8, Object a9, Object a10, Object a11,
14.3113 + Object a12, Object a13, Object a14, Object a15,
14.3114 + Object a16) throws Throwable {
14.3115 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3116 + a10, a11),
14.3117 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3118 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.3119 + Object a4, Object a5, Object a6, Object a7,
14.3120 + Object a8, Object a9, Object a10, Object a11,
14.3121 + Object a12, Object a13, Object a14, Object a15,
14.3122 + Object a16) throws Throwable {
14.3123 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3124 + a10, a11, a12),
14.3125 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3126 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.3127 + Object a4, Object a5, Object a6, Object a7,
14.3128 + Object a8, Object a9, Object a10, Object a11,
14.3129 + Object a12, Object a13, Object a14, Object a15,
14.3130 + Object a16) throws Throwable {
14.3131 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3132 + a10, a11, a12, a13),
14.3133 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3134 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.3135 + Object a4, Object a5, Object a6, Object a7,
14.3136 + Object a8, Object a9, Object a10, Object a11,
14.3137 + Object a12, Object a13, Object a14, Object a15,
14.3138 + Object a16) throws Throwable {
14.3139 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3140 + a10, a11, a12, a13, a14),
14.3141 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3142 + protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
14.3143 + Object a4, Object a5, Object a6, Object a7,
14.3144 + Object a8, Object a9, Object a10, Object a11,
14.3145 + Object a12, Object a13, Object a14, Object a15,
14.3146 + Object a16) throws Throwable {
14.3147 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3148 + a10, a11, a12, a13, a14, a15),
14.3149 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3150 + protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
14.3151 + Object a4, Object a5, Object a6, Object a7,
14.3152 + Object a8, Object a9, Object a10, Object a11,
14.3153 + Object a12, Object a13, Object a14, Object a15,
14.3154 + Object a16) throws Throwable {
14.3155 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16),
14.3156 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); }
14.3157 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.3158 + Object a4, Object a5, Object a6, Object a7,
14.3159 + Object a8, Object a9, Object a10, Object a11,
14.3160 + Object a12, Object a13, Object a14, Object a15,
14.3161 + Object a16) throws Throwable {
14.3162 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3163 + a10, a11, a12, a13, a14, a15, a16)); }
14.3164 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.3165 + Object a4, Object a5, Object a6, Object a7,
14.3166 + Object a8, Object a9, Object a10, Object a11,
14.3167 + Object a12, Object a13, Object a14, Object a15,
14.3168 + Object a16) throws Throwable {
14.3169 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3170 + a10, a11, a12, a13, a14, a15, a16)); }
14.3171 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.3172 + Object a4, Object a5, Object a6, Object a7,
14.3173 + Object a8, Object a9, Object a10, Object a11,
14.3174 + Object a12, Object a13, Object a14, Object a15,
14.3175 + Object a16) throws Throwable {
14.3176 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.3177 + a10, a11, a12, a13, a14, a15, a16)); }
14.3178 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.3179 + Object a4, Object a5, Object a6, Object a7,
14.3180 + Object a8, Object a9, Object a10, Object a11,
14.3181 + Object a12, Object a13, Object a14, Object a15,
14.3182 + Object a16) throws Throwable {
14.3183 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.3184 + a10, a11, a12, a13, a14, a15, a16)); }
14.3185 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.3186 + Object a4, Object a5, Object a6, Object a7,
14.3187 + Object a8, Object a9, Object a10, Object a11,
14.3188 + Object a12, Object a13, Object a14, Object a15,
14.3189 + Object a16) throws Throwable {
14.3190 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.3191 + a10, a11, a12, a13, a14, a15, a16)); }
14.3192 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.3193 + Object a4, Object a5, Object a6, Object a7,
14.3194 + Object a8, Object a9, Object a10, Object a11,
14.3195 + Object a12, Object a13, Object a14, Object a15,
14.3196 + Object a16) throws Throwable {
14.3197 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.3198 + a10, a11, a12, a13, a14, a15, a16)); }
14.3199 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.3200 + Object a4, Object a5, Object a6, Object a7,
14.3201 + Object a8, Object a9, Object a10, Object a11,
14.3202 + Object a12, Object a13, Object a14, Object a15,
14.3203 + Object a16) throws Throwable {
14.3204 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.3205 + a10, a11, a12, a13, a14, a15, a16)); }
14.3206 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.3207 + Object a4, Object a5, Object a6, Object a7,
14.3208 + Object a8, Object a9, Object a10, Object a11,
14.3209 + Object a12, Object a13, Object a14, Object a15,
14.3210 + Object a16) throws Throwable {
14.3211 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.3212 + a10, a11, a12, a13, a14, a15, a16)); }
14.3213 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.3214 + Object a4, Object a5, Object a6, Object a7,
14.3215 + Object a8, Object a9, Object a10, Object a11,
14.3216 + Object a12, Object a13, Object a14, Object a15,
14.3217 + Object a16) throws Throwable {
14.3218 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.3219 + a10, a11, a12, a13, a14, a15, a16)); }
14.3220 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.3221 + Object a4, Object a5, Object a6, Object a7,
14.3222 + Object a8, Object a9, Object a10, Object a11,
14.3223 + Object a12, Object a13, Object a14, Object a15,
14.3224 + Object a16) throws Throwable {
14.3225 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.3226 + a10, a11, a12, a13, a14, a15, a16)); }
14.3227 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.3228 + Object a4, Object a5, Object a6, Object a7,
14.3229 + Object a8, Object a9, Object a10, Object a11,
14.3230 + Object a12, Object a13, Object a14, Object a15,
14.3231 + Object a16) throws Throwable {
14.3232 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14, a15, a16)); }
14.3233 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.3234 + Object a4, Object a5, Object a6, Object a7,
14.3235 + Object a8, Object a9, Object a10, Object a11,
14.3236 + Object a12, Object a13, Object a14, Object a15,
14.3237 + Object a16) throws Throwable {
14.3238 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3239 + a10, filter.invoke(a11, a12, a13, a14, a15, a16)); }
14.3240 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.3241 + Object a4, Object a5, Object a6, Object a7,
14.3242 + Object a8, Object a9, Object a10, Object a11,
14.3243 + Object a12, Object a13, Object a14, Object a15,
14.3244 + Object a16) throws Throwable {
14.3245 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3246 + a10, a11, filter.invoke(a12, a13, a14, a15, a16)); }
14.3247 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.3248 + Object a4, Object a5, Object a6, Object a7,
14.3249 + Object a8, Object a9, Object a10, Object a11,
14.3250 + Object a12, Object a13, Object a14, Object a15,
14.3251 + Object a16) throws Throwable {
14.3252 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3253 + a10, a11, a12, filter.invoke(a13, a14, a15, a16)); }
14.3254 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.3255 + Object a4, Object a5, Object a6, Object a7,
14.3256 + Object a8, Object a9, Object a10, Object a11,
14.3257 + Object a12, Object a13, Object a14, Object a15,
14.3258 + Object a16) throws Throwable {
14.3259 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3260 + a10, a11, a12, a13, filter.invoke(a14, a15, a16)); }
14.3261 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.3262 + Object a4, Object a5, Object a6, Object a7,
14.3263 + Object a8, Object a9, Object a10, Object a11,
14.3264 + Object a12, Object a13, Object a14, Object a15,
14.3265 + Object a16) throws Throwable {
14.3266 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3267 + a10, a11, a12, a13, a14, filter.invoke(a15, a16)); }
14.3268 + protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
14.3269 + Object a4, Object a5, Object a6, Object a7,
14.3270 + Object a8, Object a9, Object a10, Object a11,
14.3271 + Object a12, Object a13, Object a14, Object a15,
14.3272 + Object a16) throws Throwable {
14.3273 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3274 + a10, a11, a12, a13, a14, a15, filter.invoke(a16)); }
14.3275 + protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
14.3276 + Object a4, Object a5, Object a6, Object a7,
14.3277 + Object a8, Object a9, Object a10, Object a11,
14.3278 + Object a12, Object a13, Object a14, Object a15,
14.3279 + Object a16) throws Throwable {
14.3280 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, filter.invoke()); }
14.3281 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.3282 + Object a4, Object a5, Object a6, Object a7,
14.3283 + Object a8, Object a9, Object a10, Object a11,
14.3284 + Object a12, Object a13, Object a14, Object a15,
14.3285 + Object a16) throws Throwable {
14.3286 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16 };
14.3287 + filter.<void>invoke(av); // make the flyby
14.3288 + return target.invoke(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]); }
14.3289 + }
14.3290 + static class F18 extends Adapter {
14.3291 + protected F18(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.3292 + protected F18(MethodHandle e, MethodHandle f, MethodHandle t) {
14.3293 + super(e, f, t); }
14.3294 + protected F18 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.3295 + return new F18(e, f, t); }
14.3296 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.3297 + Object a4, Object a5, Object a6, Object a7,
14.3298 + Object a8, Object a9, Object a10, Object a11,
14.3299 + Object a12, Object a13, Object a14, Object a15,
14.3300 + Object a16, Object a17) throws Throwable {
14.3301 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3302 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3303 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.3304 + Object a4, Object a5, Object a6, Object a7,
14.3305 + Object a8, Object a9, Object a10, Object a11,
14.3306 + Object a12, Object a13, Object a14, Object a15,
14.3307 + Object a16, Object a17) throws Throwable {
14.3308 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.3309 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3310 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.3311 + Object a4, Object a5, Object a6, Object a7,
14.3312 + Object a8, Object a9, Object a10, Object a11,
14.3313 + Object a12, Object a13, Object a14, Object a15,
14.3314 + Object a16, Object a17) throws Throwable {
14.3315 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.3316 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3317 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.3318 + Object a4, Object a5, Object a6, Object a7,
14.3319 + Object a8, Object a9, Object a10, Object a11,
14.3320 + Object a12, Object a13, Object a14, Object a15,
14.3321 + Object a16, Object a17) throws Throwable {
14.3322 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.3323 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3324 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.3325 + Object a4, Object a5, Object a6, Object a7,
14.3326 + Object a8, Object a9, Object a10, Object a11,
14.3327 + Object a12, Object a13, Object a14, Object a15,
14.3328 + Object a16, Object a17) throws Throwable {
14.3329 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.3330 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3331 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.3332 + Object a4, Object a5, Object a6, Object a7,
14.3333 + Object a8, Object a9, Object a10, Object a11,
14.3334 + Object a12, Object a13, Object a14, Object a15,
14.3335 + Object a16, Object a17) throws Throwable {
14.3336 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.3337 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3338 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.3339 + Object a4, Object a5, Object a6, Object a7,
14.3340 + Object a8, Object a9, Object a10, Object a11,
14.3341 + Object a12, Object a13, Object a14, Object a15,
14.3342 + Object a16, Object a17) throws Throwable {
14.3343 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.3344 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3345 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.3346 + Object a4, Object a5, Object a6, Object a7,
14.3347 + Object a8, Object a9, Object a10, Object a11,
14.3348 + Object a12, Object a13, Object a14, Object a15,
14.3349 + Object a16, Object a17) throws Throwable {
14.3350 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.3351 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3352 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.3353 + Object a4, Object a5, Object a6, Object a7,
14.3354 + Object a8, Object a9, Object a10, Object a11,
14.3355 + Object a12, Object a13, Object a14, Object a15,
14.3356 + Object a16, Object a17) throws Throwable {
14.3357 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.3358 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3359 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.3360 + Object a4, Object a5, Object a6, Object a7,
14.3361 + Object a8, Object a9, Object a10, Object a11,
14.3362 + Object a12, Object a13, Object a14, Object a15,
14.3363 + Object a16, Object a17) throws Throwable {
14.3364 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.3365 + a10, a11, a12, a13, a14, a15, a16, a17); }
14.3366 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.3367 + Object a4, Object a5, Object a6, Object a7,
14.3368 + Object a8, Object a9, Object a10, Object a11,
14.3369 + Object a12, Object a13, Object a14, Object a15,
14.3370 + Object a16, Object a17) throws Throwable {
14.3371 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3372 + filter.invoke(a10), a11, a12, a13, a14, a15, a16, a17); }
14.3373 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.3374 + Object a4, Object a5, Object a6, Object a7,
14.3375 + Object a8, Object a9, Object a10, Object a11,
14.3376 + Object a12, Object a13, Object a14, Object a15,
14.3377 + Object a16, Object a17) throws Throwable {
14.3378 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3379 + a10, filter.invoke(a11), a12, a13, a14, a15, a16, a17); }
14.3380 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.3381 + Object a4, Object a5, Object a6, Object a7,
14.3382 + Object a8, Object a9, Object a10, Object a11,
14.3383 + Object a12, Object a13, Object a14, Object a15,
14.3384 + Object a16, Object a17) throws Throwable {
14.3385 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3386 + a10, a11, filter.invoke(a12), a13, a14, a15, a16, a17); }
14.3387 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.3388 + Object a4, Object a5, Object a6, Object a7,
14.3389 + Object a8, Object a9, Object a10, Object a11,
14.3390 + Object a12, Object a13, Object a14, Object a15,
14.3391 + Object a16, Object a17) throws Throwable {
14.3392 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3393 + a10, a11, a12, filter.invoke(a13), a14, a15, a16, a17); }
14.3394 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.3395 + Object a4, Object a5, Object a6, Object a7,
14.3396 + Object a8, Object a9, Object a10, Object a11,
14.3397 + Object a12, Object a13, Object a14, Object a15,
14.3398 + Object a16, Object a17) throws Throwable {
14.3399 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3400 + a10, a11, a12, a13, filter.invoke(a14), a15, a16, a17); }
14.3401 + protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
14.3402 + Object a4, Object a5, Object a6, Object a7,
14.3403 + Object a8, Object a9, Object a10, Object a11,
14.3404 + Object a12, Object a13, Object a14, Object a15,
14.3405 + Object a16, Object a17) throws Throwable {
14.3406 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3407 + a10, a11, a12, a13, a14, filter.invoke(a15), a16, a17); }
14.3408 + protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
14.3409 + Object a4, Object a5, Object a6, Object a7,
14.3410 + Object a8, Object a9, Object a10, Object a11,
14.3411 + Object a12, Object a13, Object a14, Object a15,
14.3412 + Object a16, Object a17) throws Throwable {
14.3413 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3414 + a10, a11, a12, a13, a14, a15, filter.invoke(a16), a17); }
14.3415 + protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
14.3416 + Object a4, Object a5, Object a6, Object a7,
14.3417 + Object a8, Object a9, Object a10, Object a11,
14.3418 + Object a12, Object a13, Object a14, Object a15,
14.3419 + Object a16, Object a17) throws Throwable {
14.3420 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3421 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17)); }
14.3422 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.3423 + Object a4, Object a5, Object a6, Object a7,
14.3424 + Object a8, Object a9, Object a10, Object a11,
14.3425 + Object a12, Object a13, Object a14, Object a15,
14.3426 + Object a16, Object a17) throws Throwable {
14.3427 + return target.invoke(filter.invoke(),
14.3428 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3429 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.3430 + Object a4, Object a5, Object a6, Object a7,
14.3431 + Object a8, Object a9, Object a10, Object a11,
14.3432 + Object a12, Object a13, Object a14, Object a15,
14.3433 + Object a16, Object a17) throws Throwable {
14.3434 + return target.invoke(filter.invoke(a0),
14.3435 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3436 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.3437 + Object a4, Object a5, Object a6, Object a7,
14.3438 + Object a8, Object a9, Object a10, Object a11,
14.3439 + Object a12, Object a13, Object a14, Object a15,
14.3440 + Object a16, Object a17) throws Throwable {
14.3441 + return target.invoke(filter.invoke(a0, a1),
14.3442 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3443 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.3444 + Object a4, Object a5, Object a6, Object a7,
14.3445 + Object a8, Object a9, Object a10, Object a11,
14.3446 + Object a12, Object a13, Object a14, Object a15,
14.3447 + Object a16, Object a17) throws Throwable {
14.3448 + return target.invoke(filter.invoke(a0, a1, a2),
14.3449 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3450 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.3451 + Object a4, Object a5, Object a6, Object a7,
14.3452 + Object a8, Object a9, Object a10, Object a11,
14.3453 + Object a12, Object a13, Object a14, Object a15,
14.3454 + Object a16, Object a17) throws Throwable {
14.3455 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.3456 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3457 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.3458 + Object a4, Object a5, Object a6, Object a7,
14.3459 + Object a8, Object a9, Object a10, Object a11,
14.3460 + Object a12, Object a13, Object a14, Object a15,
14.3461 + Object a16, Object a17) throws Throwable {
14.3462 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.3463 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3464 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.3465 + Object a4, Object a5, Object a6, Object a7,
14.3466 + Object a8, Object a9, Object a10, Object a11,
14.3467 + Object a12, Object a13, Object a14, Object a15,
14.3468 + Object a16, Object a17) throws Throwable {
14.3469 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.3470 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3471 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.3472 + Object a4, Object a5, Object a6, Object a7,
14.3473 + Object a8, Object a9, Object a10, Object a11,
14.3474 + Object a12, Object a13, Object a14, Object a15,
14.3475 + Object a16, Object a17) throws Throwable {
14.3476 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.3477 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3478 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.3479 + Object a4, Object a5, Object a6, Object a7,
14.3480 + Object a8, Object a9, Object a10, Object a11,
14.3481 + Object a12, Object a13, Object a14, Object a15,
14.3482 + Object a16, Object a17) throws Throwable {
14.3483 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.3484 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3485 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.3486 + Object a4, Object a5, Object a6, Object a7,
14.3487 + Object a8, Object a9, Object a10, Object a11,
14.3488 + Object a12, Object a13, Object a14, Object a15,
14.3489 + Object a16, Object a17) throws Throwable {
14.3490 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.3491 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3492 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.3493 + Object a4, Object a5, Object a6, Object a7,
14.3494 + Object a8, Object a9, Object a10, Object a11,
14.3495 + Object a12, Object a13, Object a14, Object a15,
14.3496 + Object a16, Object a17) throws Throwable {
14.3497 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.3498 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3499 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.3500 + Object a4, Object a5, Object a6, Object a7,
14.3501 + Object a8, Object a9, Object a10, Object a11,
14.3502 + Object a12, Object a13, Object a14, Object a15,
14.3503 + Object a16, Object a17) throws Throwable {
14.3504 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3505 + a10),
14.3506 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3507 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.3508 + Object a4, Object a5, Object a6, Object a7,
14.3509 + Object a8, Object a9, Object a10, Object a11,
14.3510 + Object a12, Object a13, Object a14, Object a15,
14.3511 + Object a16, Object a17) throws Throwable {
14.3512 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3513 + a10, a11),
14.3514 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3515 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.3516 + Object a4, Object a5, Object a6, Object a7,
14.3517 + Object a8, Object a9, Object a10, Object a11,
14.3518 + Object a12, Object a13, Object a14, Object a15,
14.3519 + Object a16, Object a17) throws Throwable {
14.3520 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3521 + a10, a11, a12),
14.3522 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3523 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.3524 + Object a4, Object a5, Object a6, Object a7,
14.3525 + Object a8, Object a9, Object a10, Object a11,
14.3526 + Object a12, Object a13, Object a14, Object a15,
14.3527 + Object a16, Object a17) throws Throwable {
14.3528 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3529 + a10, a11, a12, a13),
14.3530 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3531 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.3532 + Object a4, Object a5, Object a6, Object a7,
14.3533 + Object a8, Object a9, Object a10, Object a11,
14.3534 + Object a12, Object a13, Object a14, Object a15,
14.3535 + Object a16, Object a17) throws Throwable {
14.3536 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3537 + a10, a11, a12, a13, a14),
14.3538 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3539 + protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
14.3540 + Object a4, Object a5, Object a6, Object a7,
14.3541 + Object a8, Object a9, Object a10, Object a11,
14.3542 + Object a12, Object a13, Object a14, Object a15,
14.3543 + Object a16, Object a17) throws Throwable {
14.3544 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3545 + a10, a11, a12, a13, a14, a15),
14.3546 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3547 + protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
14.3548 + Object a4, Object a5, Object a6, Object a7,
14.3549 + Object a8, Object a9, Object a10, Object a11,
14.3550 + Object a12, Object a13, Object a14, Object a15,
14.3551 + Object a16, Object a17) throws Throwable {
14.3552 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3553 + a10, a11, a12, a13, a14, a15, a16),
14.3554 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3555 + protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
14.3556 + Object a4, Object a5, Object a6, Object a7,
14.3557 + Object a8, Object a9, Object a10, Object a11,
14.3558 + Object a12, Object a13, Object a14, Object a15,
14.3559 + Object a16, Object a17) throws Throwable {
14.3560 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17),
14.3561 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); }
14.3562 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.3563 + Object a4, Object a5, Object a6, Object a7,
14.3564 + Object a8, Object a9, Object a10, Object a11,
14.3565 + Object a12, Object a13, Object a14, Object a15,
14.3566 + Object a16, Object a17) throws Throwable {
14.3567 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3568 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3569 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.3570 + Object a4, Object a5, Object a6, Object a7,
14.3571 + Object a8, Object a9, Object a10, Object a11,
14.3572 + Object a12, Object a13, Object a14, Object a15,
14.3573 + Object a16, Object a17) throws Throwable {
14.3574 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3575 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3576 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.3577 + Object a4, Object a5, Object a6, Object a7,
14.3578 + Object a8, Object a9, Object a10, Object a11,
14.3579 + Object a12, Object a13, Object a14, Object a15,
14.3580 + Object a16, Object a17) throws Throwable {
14.3581 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.3582 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3583 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.3584 + Object a4, Object a5, Object a6, Object a7,
14.3585 + Object a8, Object a9, Object a10, Object a11,
14.3586 + Object a12, Object a13, Object a14, Object a15,
14.3587 + Object a16, Object a17) throws Throwable {
14.3588 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.3589 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3590 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.3591 + Object a4, Object a5, Object a6, Object a7,
14.3592 + Object a8, Object a9, Object a10, Object a11,
14.3593 + Object a12, Object a13, Object a14, Object a15,
14.3594 + Object a16, Object a17) throws Throwable {
14.3595 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.3596 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3597 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.3598 + Object a4, Object a5, Object a6, Object a7,
14.3599 + Object a8, Object a9, Object a10, Object a11,
14.3600 + Object a12, Object a13, Object a14, Object a15,
14.3601 + Object a16, Object a17) throws Throwable {
14.3602 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.3603 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3604 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.3605 + Object a4, Object a5, Object a6, Object a7,
14.3606 + Object a8, Object a9, Object a10, Object a11,
14.3607 + Object a12, Object a13, Object a14, Object a15,
14.3608 + Object a16, Object a17) throws Throwable {
14.3609 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.3610 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3611 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.3612 + Object a4, Object a5, Object a6, Object a7,
14.3613 + Object a8, Object a9, Object a10, Object a11,
14.3614 + Object a12, Object a13, Object a14, Object a15,
14.3615 + Object a16, Object a17) throws Throwable {
14.3616 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.3617 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3618 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.3619 + Object a4, Object a5, Object a6, Object a7,
14.3620 + Object a8, Object a9, Object a10, Object a11,
14.3621 + Object a12, Object a13, Object a14, Object a15,
14.3622 + Object a16, Object a17) throws Throwable {
14.3623 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.3624 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3625 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.3626 + Object a4, Object a5, Object a6, Object a7,
14.3627 + Object a8, Object a9, Object a10, Object a11,
14.3628 + Object a12, Object a13, Object a14, Object a15,
14.3629 + Object a16, Object a17) throws Throwable {
14.3630 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.3631 + a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3632 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.3633 + Object a4, Object a5, Object a6, Object a7,
14.3634 + Object a8, Object a9, Object a10, Object a11,
14.3635 + Object a12, Object a13, Object a14, Object a15,
14.3636 + Object a16, Object a17) throws Throwable {
14.3637 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14, a15, a16, a17)); }
14.3638 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.3639 + Object a4, Object a5, Object a6, Object a7,
14.3640 + Object a8, Object a9, Object a10, Object a11,
14.3641 + Object a12, Object a13, Object a14, Object a15,
14.3642 + Object a16, Object a17) throws Throwable {
14.3643 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3644 + a10, filter.invoke(a11, a12, a13, a14, a15, a16, a17)); }
14.3645 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.3646 + Object a4, Object a5, Object a6, Object a7,
14.3647 + Object a8, Object a9, Object a10, Object a11,
14.3648 + Object a12, Object a13, Object a14, Object a15,
14.3649 + Object a16, Object a17) throws Throwable {
14.3650 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3651 + a10, a11, filter.invoke(a12, a13, a14, a15, a16, a17)); }
14.3652 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.3653 + Object a4, Object a5, Object a6, Object a7,
14.3654 + Object a8, Object a9, Object a10, Object a11,
14.3655 + Object a12, Object a13, Object a14, Object a15,
14.3656 + Object a16, Object a17) throws Throwable {
14.3657 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3658 + a10, a11, a12, filter.invoke(a13, a14, a15, a16, a17)); }
14.3659 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.3660 + Object a4, Object a5, Object a6, Object a7,
14.3661 + Object a8, Object a9, Object a10, Object a11,
14.3662 + Object a12, Object a13, Object a14, Object a15,
14.3663 + Object a16, Object a17) throws Throwable {
14.3664 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3665 + a10, a11, a12, a13, filter.invoke(a14, a15, a16, a17)); }
14.3666 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.3667 + Object a4, Object a5, Object a6, Object a7,
14.3668 + Object a8, Object a9, Object a10, Object a11,
14.3669 + Object a12, Object a13, Object a14, Object a15,
14.3670 + Object a16, Object a17) throws Throwable {
14.3671 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3672 + a10, a11, a12, a13, a14, filter.invoke(a15, a16, a17)); }
14.3673 + protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
14.3674 + Object a4, Object a5, Object a6, Object a7,
14.3675 + Object a8, Object a9, Object a10, Object a11,
14.3676 + Object a12, Object a13, Object a14, Object a15,
14.3677 + Object a16, Object a17) throws Throwable {
14.3678 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3679 + a10, a11, a12, a13, a14, a15, filter.invoke(a16, a17)); }
14.3680 + protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
14.3681 + Object a4, Object a5, Object a6, Object a7,
14.3682 + Object a8, Object a9, Object a10, Object a11,
14.3683 + Object a12, Object a13, Object a14, Object a15,
14.3684 + Object a16, Object a17) throws Throwable {
14.3685 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3686 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17)); }
14.3687 + protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
14.3688 + Object a4, Object a5, Object a6, Object a7,
14.3689 + Object a8, Object a9, Object a10, Object a11,
14.3690 + Object a12, Object a13, Object a14, Object a15,
14.3691 + Object a16, Object a17) throws Throwable {
14.3692 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, filter.invoke()); }
14.3693 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.3694 + Object a4, Object a5, Object a6, Object a7,
14.3695 + Object a8, Object a9, Object a10, Object a11,
14.3696 + Object a12, Object a13, Object a14, Object a15,
14.3697 + Object a16, Object a17) throws Throwable {
14.3698 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17 };
14.3699 + filter.<void>invoke(av); // make the flyby
14.3700 + return target.invoke(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]); }
14.3701 + }
14.3702 + static class F19 extends Adapter {
14.3703 + protected F19(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.3704 + protected F19(MethodHandle e, MethodHandle f, MethodHandle t) {
14.3705 + super(e, f, t); }
14.3706 + protected F19 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.3707 + return new F19(e, f, t); }
14.3708 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.3709 + Object a4, Object a5, Object a6, Object a7,
14.3710 + Object a8, Object a9, Object a10, Object a11,
14.3711 + Object a12, Object a13, Object a14, Object a15,
14.3712 + Object a16, Object a17, Object a18) throws Throwable {
14.3713 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3714 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3715 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.3716 + Object a4, Object a5, Object a6, Object a7,
14.3717 + Object a8, Object a9, Object a10, Object a11,
14.3718 + Object a12, Object a13, Object a14, Object a15,
14.3719 + Object a16, Object a17, Object a18) throws Throwable {
14.3720 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.3721 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3722 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.3723 + Object a4, Object a5, Object a6, Object a7,
14.3724 + Object a8, Object a9, Object a10, Object a11,
14.3725 + Object a12, Object a13, Object a14, Object a15,
14.3726 + Object a16, Object a17, Object a18) throws Throwable {
14.3727 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.3728 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3729 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.3730 + Object a4, Object a5, Object a6, Object a7,
14.3731 + Object a8, Object a9, Object a10, Object a11,
14.3732 + Object a12, Object a13, Object a14, Object a15,
14.3733 + Object a16, Object a17, Object a18) throws Throwable {
14.3734 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.3735 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3736 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.3737 + Object a4, Object a5, Object a6, Object a7,
14.3738 + Object a8, Object a9, Object a10, Object a11,
14.3739 + Object a12, Object a13, Object a14, Object a15,
14.3740 + Object a16, Object a17, Object a18) throws Throwable {
14.3741 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.3742 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3743 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.3744 + Object a4, Object a5, Object a6, Object a7,
14.3745 + Object a8, Object a9, Object a10, Object a11,
14.3746 + Object a12, Object a13, Object a14, Object a15,
14.3747 + Object a16, Object a17, Object a18) throws Throwable {
14.3748 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.3749 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3750 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.3751 + Object a4, Object a5, Object a6, Object a7,
14.3752 + Object a8, Object a9, Object a10, Object a11,
14.3753 + Object a12, Object a13, Object a14, Object a15,
14.3754 + Object a16, Object a17, Object a18) throws Throwable {
14.3755 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.3756 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3757 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.3758 + Object a4, Object a5, Object a6, Object a7,
14.3759 + Object a8, Object a9, Object a10, Object a11,
14.3760 + Object a12, Object a13, Object a14, Object a15,
14.3761 + Object a16, Object a17, Object a18) throws Throwable {
14.3762 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.3763 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3764 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.3765 + Object a4, Object a5, Object a6, Object a7,
14.3766 + Object a8, Object a9, Object a10, Object a11,
14.3767 + Object a12, Object a13, Object a14, Object a15,
14.3768 + Object a16, Object a17, Object a18) throws Throwable {
14.3769 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.3770 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3771 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.3772 + Object a4, Object a5, Object a6, Object a7,
14.3773 + Object a8, Object a9, Object a10, Object a11,
14.3774 + Object a12, Object a13, Object a14, Object a15,
14.3775 + Object a16, Object a17, Object a18) throws Throwable {
14.3776 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.3777 + a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3778 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.3779 + Object a4, Object a5, Object a6, Object a7,
14.3780 + Object a8, Object a9, Object a10, Object a11,
14.3781 + Object a12, Object a13, Object a14, Object a15,
14.3782 + Object a16, Object a17, Object a18) throws Throwable {
14.3783 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3784 + filter.invoke(a10), a11, a12, a13, a14, a15, a16, a17, a18); }
14.3785 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.3786 + Object a4, Object a5, Object a6, Object a7,
14.3787 + Object a8, Object a9, Object a10, Object a11,
14.3788 + Object a12, Object a13, Object a14, Object a15,
14.3789 + Object a16, Object a17, Object a18) throws Throwable {
14.3790 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3791 + a10, filter.invoke(a11), a12, a13, a14, a15, a16, a17, a18); }
14.3792 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.3793 + Object a4, Object a5, Object a6, Object a7,
14.3794 + Object a8, Object a9, Object a10, Object a11,
14.3795 + Object a12, Object a13, Object a14, Object a15,
14.3796 + Object a16, Object a17, Object a18) throws Throwable {
14.3797 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3798 + a10, a11, filter.invoke(a12), a13, a14, a15, a16, a17, a18); }
14.3799 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.3800 + Object a4, Object a5, Object a6, Object a7,
14.3801 + Object a8, Object a9, Object a10, Object a11,
14.3802 + Object a12, Object a13, Object a14, Object a15,
14.3803 + Object a16, Object a17, Object a18) throws Throwable {
14.3804 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3805 + a10, a11, a12, filter.invoke(a13), a14, a15, a16, a17, a18); }
14.3806 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.3807 + Object a4, Object a5, Object a6, Object a7,
14.3808 + Object a8, Object a9, Object a10, Object a11,
14.3809 + Object a12, Object a13, Object a14, Object a15,
14.3810 + Object a16, Object a17, Object a18) throws Throwable {
14.3811 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3812 + a10, a11, a12, a13, filter.invoke(a14), a15, a16, a17, a18); }
14.3813 + protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
14.3814 + Object a4, Object a5, Object a6, Object a7,
14.3815 + Object a8, Object a9, Object a10, Object a11,
14.3816 + Object a12, Object a13, Object a14, Object a15,
14.3817 + Object a16, Object a17, Object a18) throws Throwable {
14.3818 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3819 + a10, a11, a12, a13, a14, filter.invoke(a15), a16, a17, a18); }
14.3820 + protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
14.3821 + Object a4, Object a5, Object a6, Object a7,
14.3822 + Object a8, Object a9, Object a10, Object a11,
14.3823 + Object a12, Object a13, Object a14, Object a15,
14.3824 + Object a16, Object a17, Object a18) throws Throwable {
14.3825 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3826 + a10, a11, a12, a13, a14, a15, filter.invoke(a16), a17, a18); }
14.3827 + protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
14.3828 + Object a4, Object a5, Object a6, Object a7,
14.3829 + Object a8, Object a9, Object a10, Object a11,
14.3830 + Object a12, Object a13, Object a14, Object a15,
14.3831 + Object a16, Object a17, Object a18) throws Throwable {
14.3832 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3833 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17), a18); }
14.3834 + protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
14.3835 + Object a4, Object a5, Object a6, Object a7,
14.3836 + Object a8, Object a9, Object a10, Object a11,
14.3837 + Object a12, Object a13, Object a14, Object a15,
14.3838 + Object a16, Object a17, Object a18) throws Throwable {
14.3839 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3840 + a10, a11, a12, a13, a14, a15, a16, a17, filter.invoke(a18)); }
14.3841 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.3842 + Object a4, Object a5, Object a6, Object a7,
14.3843 + Object a8, Object a9, Object a10, Object a11,
14.3844 + Object a12, Object a13, Object a14, Object a15,
14.3845 + Object a16, Object a17, Object a18) throws Throwable {
14.3846 + return target.invoke(filter.invoke(),
14.3847 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3848 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.3849 + Object a4, Object a5, Object a6, Object a7,
14.3850 + Object a8, Object a9, Object a10, Object a11,
14.3851 + Object a12, Object a13, Object a14, Object a15,
14.3852 + Object a16, Object a17, Object a18) throws Throwable {
14.3853 + return target.invoke(filter.invoke(a0),
14.3854 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3855 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.3856 + Object a4, Object a5, Object a6, Object a7,
14.3857 + Object a8, Object a9, Object a10, Object a11,
14.3858 + Object a12, Object a13, Object a14, Object a15,
14.3859 + Object a16, Object a17, Object a18) throws Throwable {
14.3860 + return target.invoke(filter.invoke(a0, a1),
14.3861 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3862 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.3863 + Object a4, Object a5, Object a6, Object a7,
14.3864 + Object a8, Object a9, Object a10, Object a11,
14.3865 + Object a12, Object a13, Object a14, Object a15,
14.3866 + Object a16, Object a17, Object a18) throws Throwable {
14.3867 + return target.invoke(filter.invoke(a0, a1, a2),
14.3868 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3869 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.3870 + Object a4, Object a5, Object a6, Object a7,
14.3871 + Object a8, Object a9, Object a10, Object a11,
14.3872 + Object a12, Object a13, Object a14, Object a15,
14.3873 + Object a16, Object a17, Object a18) throws Throwable {
14.3874 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.3875 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3876 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.3877 + Object a4, Object a5, Object a6, Object a7,
14.3878 + Object a8, Object a9, Object a10, Object a11,
14.3879 + Object a12, Object a13, Object a14, Object a15,
14.3880 + Object a16, Object a17, Object a18) throws Throwable {
14.3881 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.3882 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3883 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.3884 + Object a4, Object a5, Object a6, Object a7,
14.3885 + Object a8, Object a9, Object a10, Object a11,
14.3886 + Object a12, Object a13, Object a14, Object a15,
14.3887 + Object a16, Object a17, Object a18) throws Throwable {
14.3888 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.3889 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3890 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.3891 + Object a4, Object a5, Object a6, Object a7,
14.3892 + Object a8, Object a9, Object a10, Object a11,
14.3893 + Object a12, Object a13, Object a14, Object a15,
14.3894 + Object a16, Object a17, Object a18) throws Throwable {
14.3895 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.3896 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3897 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.3898 + Object a4, Object a5, Object a6, Object a7,
14.3899 + Object a8, Object a9, Object a10, Object a11,
14.3900 + Object a12, Object a13, Object a14, Object a15,
14.3901 + Object a16, Object a17, Object a18) throws Throwable {
14.3902 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.3903 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3904 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.3905 + Object a4, Object a5, Object a6, Object a7,
14.3906 + Object a8, Object a9, Object a10, Object a11,
14.3907 + Object a12, Object a13, Object a14, Object a15,
14.3908 + Object a16, Object a17, Object a18) throws Throwable {
14.3909 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.3910 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3911 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.3912 + Object a4, Object a5, Object a6, Object a7,
14.3913 + Object a8, Object a9, Object a10, Object a11,
14.3914 + Object a12, Object a13, Object a14, Object a15,
14.3915 + Object a16, Object a17, Object a18) throws Throwable {
14.3916 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.3917 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3918 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.3919 + Object a4, Object a5, Object a6, Object a7,
14.3920 + Object a8, Object a9, Object a10, Object a11,
14.3921 + Object a12, Object a13, Object a14, Object a15,
14.3922 + Object a16, Object a17, Object a18) throws Throwable {
14.3923 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3924 + a10),
14.3925 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3926 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.3927 + Object a4, Object a5, Object a6, Object a7,
14.3928 + Object a8, Object a9, Object a10, Object a11,
14.3929 + Object a12, Object a13, Object a14, Object a15,
14.3930 + Object a16, Object a17, Object a18) throws Throwable {
14.3931 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3932 + a10, a11),
14.3933 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3934 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.3935 + Object a4, Object a5, Object a6, Object a7,
14.3936 + Object a8, Object a9, Object a10, Object a11,
14.3937 + Object a12, Object a13, Object a14, Object a15,
14.3938 + Object a16, Object a17, Object a18) throws Throwable {
14.3939 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3940 + a10, a11, a12),
14.3941 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3942 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.3943 + Object a4, Object a5, Object a6, Object a7,
14.3944 + Object a8, Object a9, Object a10, Object a11,
14.3945 + Object a12, Object a13, Object a14, Object a15,
14.3946 + Object a16, Object a17, Object a18) throws Throwable {
14.3947 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3948 + a10, a11, a12, a13),
14.3949 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3950 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.3951 + Object a4, Object a5, Object a6, Object a7,
14.3952 + Object a8, Object a9, Object a10, Object a11,
14.3953 + Object a12, Object a13, Object a14, Object a15,
14.3954 + Object a16, Object a17, Object a18) throws Throwable {
14.3955 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3956 + a10, a11, a12, a13, a14),
14.3957 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3958 + protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
14.3959 + Object a4, Object a5, Object a6, Object a7,
14.3960 + Object a8, Object a9, Object a10, Object a11,
14.3961 + Object a12, Object a13, Object a14, Object a15,
14.3962 + Object a16, Object a17, Object a18) throws Throwable {
14.3963 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3964 + a10, a11, a12, a13, a14, a15),
14.3965 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3966 + protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
14.3967 + Object a4, Object a5, Object a6, Object a7,
14.3968 + Object a8, Object a9, Object a10, Object a11,
14.3969 + Object a12, Object a13, Object a14, Object a15,
14.3970 + Object a16, Object a17, Object a18) throws Throwable {
14.3971 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3972 + a10, a11, a12, a13, a14, a15, a16),
14.3973 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3974 + protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
14.3975 + Object a4, Object a5, Object a6, Object a7,
14.3976 + Object a8, Object a9, Object a10, Object a11,
14.3977 + Object a12, Object a13, Object a14, Object a15,
14.3978 + Object a16, Object a17, Object a18) throws Throwable {
14.3979 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3980 + a10, a11, a12, a13, a14, a15, a16, a17),
14.3981 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3982 + protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
14.3983 + Object a4, Object a5, Object a6, Object a7,
14.3984 + Object a8, Object a9, Object a10, Object a11,
14.3985 + Object a12, Object a13, Object a14, Object a15,
14.3986 + Object a16, Object a17, Object a18) throws Throwable {
14.3987 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18),
14.3988 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); }
14.3989 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.3990 + Object a4, Object a5, Object a6, Object a7,
14.3991 + Object a8, Object a9, Object a10, Object a11,
14.3992 + Object a12, Object a13, Object a14, Object a15,
14.3993 + Object a16, Object a17, Object a18) throws Throwable {
14.3994 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.3995 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.3996 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.3997 + Object a4, Object a5, Object a6, Object a7,
14.3998 + Object a8, Object a9, Object a10, Object a11,
14.3999 + Object a12, Object a13, Object a14, Object a15,
14.4000 + Object a16, Object a17, Object a18) throws Throwable {
14.4001 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4002 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4003 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.4004 + Object a4, Object a5, Object a6, Object a7,
14.4005 + Object a8, Object a9, Object a10, Object a11,
14.4006 + Object a12, Object a13, Object a14, Object a15,
14.4007 + Object a16, Object a17, Object a18) throws Throwable {
14.4008 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.4009 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4010 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.4011 + Object a4, Object a5, Object a6, Object a7,
14.4012 + Object a8, Object a9, Object a10, Object a11,
14.4013 + Object a12, Object a13, Object a14, Object a15,
14.4014 + Object a16, Object a17, Object a18) throws Throwable {
14.4015 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.4016 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4017 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.4018 + Object a4, Object a5, Object a6, Object a7,
14.4019 + Object a8, Object a9, Object a10, Object a11,
14.4020 + Object a12, Object a13, Object a14, Object a15,
14.4021 + Object a16, Object a17, Object a18) throws Throwable {
14.4022 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.4023 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4024 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.4025 + Object a4, Object a5, Object a6, Object a7,
14.4026 + Object a8, Object a9, Object a10, Object a11,
14.4027 + Object a12, Object a13, Object a14, Object a15,
14.4028 + Object a16, Object a17, Object a18) throws Throwable {
14.4029 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.4030 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4031 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.4032 + Object a4, Object a5, Object a6, Object a7,
14.4033 + Object a8, Object a9, Object a10, Object a11,
14.4034 + Object a12, Object a13, Object a14, Object a15,
14.4035 + Object a16, Object a17, Object a18) throws Throwable {
14.4036 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.4037 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4038 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.4039 + Object a4, Object a5, Object a6, Object a7,
14.4040 + Object a8, Object a9, Object a10, Object a11,
14.4041 + Object a12, Object a13, Object a14, Object a15,
14.4042 + Object a16, Object a17, Object a18) throws Throwable {
14.4043 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.4044 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4045 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.4046 + Object a4, Object a5, Object a6, Object a7,
14.4047 + Object a8, Object a9, Object a10, Object a11,
14.4048 + Object a12, Object a13, Object a14, Object a15,
14.4049 + Object a16, Object a17, Object a18) throws Throwable {
14.4050 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.4051 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4052 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.4053 + Object a4, Object a5, Object a6, Object a7,
14.4054 + Object a8, Object a9, Object a10, Object a11,
14.4055 + Object a12, Object a13, Object a14, Object a15,
14.4056 + Object a16, Object a17, Object a18) throws Throwable {
14.4057 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.4058 + a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4059 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.4060 + Object a4, Object a5, Object a6, Object a7,
14.4061 + Object a8, Object a9, Object a10, Object a11,
14.4062 + Object a12, Object a13, Object a14, Object a15,
14.4063 + Object a16, Object a17, Object a18) throws Throwable {
14.4064 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4065 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.4066 + Object a4, Object a5, Object a6, Object a7,
14.4067 + Object a8, Object a9, Object a10, Object a11,
14.4068 + Object a12, Object a13, Object a14, Object a15,
14.4069 + Object a16, Object a17, Object a18) throws Throwable {
14.4070 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4071 + a10, filter.invoke(a11, a12, a13, a14, a15, a16, a17, a18)); }
14.4072 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.4073 + Object a4, Object a5, Object a6, Object a7,
14.4074 + Object a8, Object a9, Object a10, Object a11,
14.4075 + Object a12, Object a13, Object a14, Object a15,
14.4076 + Object a16, Object a17, Object a18) throws Throwable {
14.4077 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4078 + a10, a11, filter.invoke(a12, a13, a14, a15, a16, a17, a18)); }
14.4079 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.4080 + Object a4, Object a5, Object a6, Object a7,
14.4081 + Object a8, Object a9, Object a10, Object a11,
14.4082 + Object a12, Object a13, Object a14, Object a15,
14.4083 + Object a16, Object a17, Object a18) throws Throwable {
14.4084 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4085 + a10, a11, a12, filter.invoke(a13, a14, a15, a16, a17, a18)); }
14.4086 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.4087 + Object a4, Object a5, Object a6, Object a7,
14.4088 + Object a8, Object a9, Object a10, Object a11,
14.4089 + Object a12, Object a13, Object a14, Object a15,
14.4090 + Object a16, Object a17, Object a18) throws Throwable {
14.4091 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4092 + a10, a11, a12, a13, filter.invoke(a14, a15, a16, a17, a18)); }
14.4093 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.4094 + Object a4, Object a5, Object a6, Object a7,
14.4095 + Object a8, Object a9, Object a10, Object a11,
14.4096 + Object a12, Object a13, Object a14, Object a15,
14.4097 + Object a16, Object a17, Object a18) throws Throwable {
14.4098 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4099 + a10, a11, a12, a13, a14, filter.invoke(a15, a16, a17, a18)); }
14.4100 + protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
14.4101 + Object a4, Object a5, Object a6, Object a7,
14.4102 + Object a8, Object a9, Object a10, Object a11,
14.4103 + Object a12, Object a13, Object a14, Object a15,
14.4104 + Object a16, Object a17, Object a18) throws Throwable {
14.4105 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4106 + a10, a11, a12, a13, a14, a15, filter.invoke(a16, a17, a18)); }
14.4107 + protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
14.4108 + Object a4, Object a5, Object a6, Object a7,
14.4109 + Object a8, Object a9, Object a10, Object a11,
14.4110 + Object a12, Object a13, Object a14, Object a15,
14.4111 + Object a16, Object a17, Object a18) throws Throwable {
14.4112 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4113 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17, a18)); }
14.4114 + protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
14.4115 + Object a4, Object a5, Object a6, Object a7,
14.4116 + Object a8, Object a9, Object a10, Object a11,
14.4117 + Object a12, Object a13, Object a14, Object a15,
14.4118 + Object a16, Object a17, Object a18) throws Throwable {
14.4119 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4120 + a10, a11, a12, a13, a14, a15, a16, a17, filter.invoke(a18)); }
14.4121 + protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
14.4122 + Object a4, Object a5, Object a6, Object a7,
14.4123 + Object a8, Object a9, Object a10, Object a11,
14.4124 + Object a12, Object a13, Object a14, Object a15,
14.4125 + Object a16, Object a17, Object a18) throws Throwable {
14.4126 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invoke()); }
14.4127 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.4128 + Object a4, Object a5, Object a6, Object a7,
14.4129 + Object a8, Object a9, Object a10, Object a11,
14.4130 + Object a12, Object a13, Object a14, Object a15,
14.4131 + Object a16, Object a17, Object a18) throws Throwable {
14.4132 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18 };
14.4133 + filter.<void>invoke(av); // make the flyby
14.4134 + return target.invoke(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]); }
14.4135 + }
14.4136 + static class F20 extends Adapter {
14.4137 + protected F20(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
14.4138 + protected F20(MethodHandle e, MethodHandle f, MethodHandle t) {
14.4139 + super(e, f, t); }
14.4140 + protected F20 makeInstance(MethodHandle e, MethodHandle f, MethodHandle t) {
14.4141 + return new F20(e, f, t); }
14.4142 + protected Object invoke_V0(Object a0, Object a1, Object a2, Object a3,
14.4143 + Object a4, Object a5, Object a6, Object a7,
14.4144 + Object a8, Object a9, Object a10, Object a11,
14.4145 + Object a12, Object a13, Object a14, Object a15,
14.4146 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4147 + return target.invoke(filter.invoke(a0), a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4148 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4149 + protected Object invoke_V1(Object a0, Object a1, Object a2, Object a3,
14.4150 + Object a4, Object a5, Object a6, Object a7,
14.4151 + Object a8, Object a9, Object a10, Object a11,
14.4152 + Object a12, Object a13, Object a14, Object a15,
14.4153 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4154 + return target.invoke(a0, filter.invoke(a1), a2, a3, a4, a5, a6, a7, a8, a9,
14.4155 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4156 + protected Object invoke_V2(Object a0, Object a1, Object a2, Object a3,
14.4157 + Object a4, Object a5, Object a6, Object a7,
14.4158 + Object a8, Object a9, Object a10, Object a11,
14.4159 + Object a12, Object a13, Object a14, Object a15,
14.4160 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4161 + return target.invoke(a0, a1, filter.invoke(a2), a3, a4, a5, a6, a7, a8, a9,
14.4162 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4163 + protected Object invoke_V3(Object a0, Object a1, Object a2, Object a3,
14.4164 + Object a4, Object a5, Object a6, Object a7,
14.4165 + Object a8, Object a9, Object a10, Object a11,
14.4166 + Object a12, Object a13, Object a14, Object a15,
14.4167 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4168 + return target.invoke(a0, a1, a2, filter.invoke(a3), a4, a5, a6, a7, a8, a9,
14.4169 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4170 + protected Object invoke_V4(Object a0, Object a1, Object a2, Object a3,
14.4171 + Object a4, Object a5, Object a6, Object a7,
14.4172 + Object a8, Object a9, Object a10, Object a11,
14.4173 + Object a12, Object a13, Object a14, Object a15,
14.4174 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4175 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4), a5, a6, a7, a8, a9,
14.4176 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4177 + protected Object invoke_V5(Object a0, Object a1, Object a2, Object a3,
14.4178 + Object a4, Object a5, Object a6, Object a7,
14.4179 + Object a8, Object a9, Object a10, Object a11,
14.4180 + Object a12, Object a13, Object a14, Object a15,
14.4181 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4182 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5), a6, a7, a8, a9,
14.4183 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4184 + protected Object invoke_V6(Object a0, Object a1, Object a2, Object a3,
14.4185 + Object a4, Object a5, Object a6, Object a7,
14.4186 + Object a8, Object a9, Object a10, Object a11,
14.4187 + Object a12, Object a13, Object a14, Object a15,
14.4188 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4189 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6), a7, a8, a9,
14.4190 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4191 + protected Object invoke_V7(Object a0, Object a1, Object a2, Object a3,
14.4192 + Object a4, Object a5, Object a6, Object a7,
14.4193 + Object a8, Object a9, Object a10, Object a11,
14.4194 + Object a12, Object a13, Object a14, Object a15,
14.4195 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4196 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7), a8, a9,
14.4197 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4198 + protected Object invoke_V8(Object a0, Object a1, Object a2, Object a3,
14.4199 + Object a4, Object a5, Object a6, Object a7,
14.4200 + Object a8, Object a9, Object a10, Object a11,
14.4201 + Object a12, Object a13, Object a14, Object a15,
14.4202 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4203 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8), a9,
14.4204 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4205 + protected Object invoke_V9(Object a0, Object a1, Object a2, Object a3,
14.4206 + Object a4, Object a5, Object a6, Object a7,
14.4207 + Object a8, Object a9, Object a10, Object a11,
14.4208 + Object a12, Object a13, Object a14, Object a15,
14.4209 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4210 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9),
14.4211 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4212 + protected Object invoke_V10(Object a0, Object a1, Object a2, Object a3,
14.4213 + Object a4, Object a5, Object a6, Object a7,
14.4214 + Object a8, Object a9, Object a10, Object a11,
14.4215 + Object a12, Object a13, Object a14, Object a15,
14.4216 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4217 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4218 + filter.invoke(a10), a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4219 + protected Object invoke_V11(Object a0, Object a1, Object a2, Object a3,
14.4220 + Object a4, Object a5, Object a6, Object a7,
14.4221 + Object a8, Object a9, Object a10, Object a11,
14.4222 + Object a12, Object a13, Object a14, Object a15,
14.4223 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4224 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4225 + a10, filter.invoke(a11), a12, a13, a14, a15, a16, a17, a18, a19); }
14.4226 + protected Object invoke_V12(Object a0, Object a1, Object a2, Object a3,
14.4227 + Object a4, Object a5, Object a6, Object a7,
14.4228 + Object a8, Object a9, Object a10, Object a11,
14.4229 + Object a12, Object a13, Object a14, Object a15,
14.4230 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4231 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4232 + a10, a11, filter.invoke(a12), a13, a14, a15, a16, a17, a18, a19); }
14.4233 + protected Object invoke_V13(Object a0, Object a1, Object a2, Object a3,
14.4234 + Object a4, Object a5, Object a6, Object a7,
14.4235 + Object a8, Object a9, Object a10, Object a11,
14.4236 + Object a12, Object a13, Object a14, Object a15,
14.4237 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4238 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4239 + a10, a11, a12, filter.invoke(a13), a14, a15, a16, a17, a18, a19); }
14.4240 + protected Object invoke_V14(Object a0, Object a1, Object a2, Object a3,
14.4241 + Object a4, Object a5, Object a6, Object a7,
14.4242 + Object a8, Object a9, Object a10, Object a11,
14.4243 + Object a12, Object a13, Object a14, Object a15,
14.4244 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4245 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4246 + a10, a11, a12, a13, filter.invoke(a14), a15, a16, a17, a18, a19); }
14.4247 + protected Object invoke_V15(Object a0, Object a1, Object a2, Object a3,
14.4248 + Object a4, Object a5, Object a6, Object a7,
14.4249 + Object a8, Object a9, Object a10, Object a11,
14.4250 + Object a12, Object a13, Object a14, Object a15,
14.4251 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4252 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4253 + a10, a11, a12, a13, a14, filter.invoke(a15), a16, a17, a18, a19); }
14.4254 + protected Object invoke_V16(Object a0, Object a1, Object a2, Object a3,
14.4255 + Object a4, Object a5, Object a6, Object a7,
14.4256 + Object a8, Object a9, Object a10, Object a11,
14.4257 + Object a12, Object a13, Object a14, Object a15,
14.4258 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4259 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4260 + a10, a11, a12, a13, a14, a15, filter.invoke(a16), a17, a18, a19); }
14.4261 + protected Object invoke_V17(Object a0, Object a1, Object a2, Object a3,
14.4262 + Object a4, Object a5, Object a6, Object a7,
14.4263 + Object a8, Object a9, Object a10, Object a11,
14.4264 + Object a12, Object a13, Object a14, Object a15,
14.4265 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4266 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4267 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17), a18, a19); }
14.4268 + protected Object invoke_V18(Object a0, Object a1, Object a2, Object a3,
14.4269 + Object a4, Object a5, Object a6, Object a7,
14.4270 + Object a8, Object a9, Object a10, Object a11,
14.4271 + Object a12, Object a13, Object a14, Object a15,
14.4272 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4273 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4274 + a10, a11, a12, a13, a14, a15, a16, a17, filter.invoke(a18), a19); }
14.4275 + protected Object invoke_V19(Object a0, Object a1, Object a2, Object a3,
14.4276 + Object a4, Object a5, Object a6, Object a7,
14.4277 + Object a8, Object a9, Object a10, Object a11,
14.4278 + Object a12, Object a13, Object a14, Object a15,
14.4279 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4280 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4281 + a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invoke(a19)); }
14.4282 + protected Object invoke_F0(Object a0, Object a1, Object a2, Object a3,
14.4283 + Object a4, Object a5, Object a6, Object a7,
14.4284 + Object a8, Object a9, Object a10, Object a11,
14.4285 + Object a12, Object a13, Object a14, Object a15,
14.4286 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4287 + return target.invoke(filter.invoke(),
14.4288 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4289 + protected Object invoke_F1(Object a0, Object a1, Object a2, Object a3,
14.4290 + Object a4, Object a5, Object a6, Object a7,
14.4291 + Object a8, Object a9, Object a10, Object a11,
14.4292 + Object a12, Object a13, Object a14, Object a15,
14.4293 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4294 + return target.invoke(filter.invoke(a0),
14.4295 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4296 + protected Object invoke_F2(Object a0, Object a1, Object a2, Object a3,
14.4297 + Object a4, Object a5, Object a6, Object a7,
14.4298 + Object a8, Object a9, Object a10, Object a11,
14.4299 + Object a12, Object a13, Object a14, Object a15,
14.4300 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4301 + return target.invoke(filter.invoke(a0, a1),
14.4302 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4303 + protected Object invoke_F3(Object a0, Object a1, Object a2, Object a3,
14.4304 + Object a4, Object a5, Object a6, Object a7,
14.4305 + Object a8, Object a9, Object a10, Object a11,
14.4306 + Object a12, Object a13, Object a14, Object a15,
14.4307 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4308 + return target.invoke(filter.invoke(a0, a1, a2),
14.4309 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4310 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3,
14.4311 + Object a4, Object a5, Object a6, Object a7,
14.4312 + Object a8, Object a9, Object a10, Object a11,
14.4313 + Object a12, Object a13, Object a14, Object a15,
14.4314 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4315 + return target.invoke(filter.invoke(a0, a1, a2, a3),
14.4316 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4317 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3,
14.4318 + Object a4, Object a5, Object a6, Object a7,
14.4319 + Object a8, Object a9, Object a10, Object a11,
14.4320 + Object a12, Object a13, Object a14, Object a15,
14.4321 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4322 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4),
14.4323 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4324 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3,
14.4325 + Object a4, Object a5, Object a6, Object a7,
14.4326 + Object a8, Object a9, Object a10, Object a11,
14.4327 + Object a12, Object a13, Object a14, Object a15,
14.4328 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4329 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5),
14.4330 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4331 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3,
14.4332 + Object a4, Object a5, Object a6, Object a7,
14.4333 + Object a8, Object a9, Object a10, Object a11,
14.4334 + Object a12, Object a13, Object a14, Object a15,
14.4335 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4336 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6),
14.4337 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4338 + protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3,
14.4339 + Object a4, Object a5, Object a6, Object a7,
14.4340 + Object a8, Object a9, Object a10, Object a11,
14.4341 + Object a12, Object a13, Object a14, Object a15,
14.4342 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4343 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7),
14.4344 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4345 + protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3,
14.4346 + Object a4, Object a5, Object a6, Object a7,
14.4347 + Object a8, Object a9, Object a10, Object a11,
14.4348 + Object a12, Object a13, Object a14, Object a15,
14.4349 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4350 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8),
14.4351 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4352 + protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3,
14.4353 + Object a4, Object a5, Object a6, Object a7,
14.4354 + Object a8, Object a9, Object a10, Object a11,
14.4355 + Object a12, Object a13, Object a14, Object a15,
14.4356 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4357 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9),
14.4358 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4359 + protected Object invoke_F11(Object a0, Object a1, Object a2, Object a3,
14.4360 + Object a4, Object a5, Object a6, Object a7,
14.4361 + Object a8, Object a9, Object a10, Object a11,
14.4362 + Object a12, Object a13, Object a14, Object a15,
14.4363 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4364 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4365 + a10),
14.4366 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4367 + protected Object invoke_F12(Object a0, Object a1, Object a2, Object a3,
14.4368 + Object a4, Object a5, Object a6, Object a7,
14.4369 + Object a8, Object a9, Object a10, Object a11,
14.4370 + Object a12, Object a13, Object a14, Object a15,
14.4371 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4372 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4373 + a10, a11),
14.4374 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4375 + protected Object invoke_F13(Object a0, Object a1, Object a2, Object a3,
14.4376 + Object a4, Object a5, Object a6, Object a7,
14.4377 + Object a8, Object a9, Object a10, Object a11,
14.4378 + Object a12, Object a13, Object a14, Object a15,
14.4379 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4380 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4381 + a10, a11, a12),
14.4382 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4383 + protected Object invoke_F14(Object a0, Object a1, Object a2, Object a3,
14.4384 + Object a4, Object a5, Object a6, Object a7,
14.4385 + Object a8, Object a9, Object a10, Object a11,
14.4386 + Object a12, Object a13, Object a14, Object a15,
14.4387 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4388 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4389 + a10, a11, a12, a13),
14.4390 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4391 + protected Object invoke_F15(Object a0, Object a1, Object a2, Object a3,
14.4392 + Object a4, Object a5, Object a6, Object a7,
14.4393 + Object a8, Object a9, Object a10, Object a11,
14.4394 + Object a12, Object a13, Object a14, Object a15,
14.4395 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4396 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4397 + a10, a11, a12, a13, a14),
14.4398 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4399 + protected Object invoke_F16(Object a0, Object a1, Object a2, Object a3,
14.4400 + Object a4, Object a5, Object a6, Object a7,
14.4401 + Object a8, Object a9, Object a10, Object a11,
14.4402 + Object a12, Object a13, Object a14, Object a15,
14.4403 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4404 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4405 + a10, a11, a12, a13, a14, a15),
14.4406 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4407 + protected Object invoke_F17(Object a0, Object a1, Object a2, Object a3,
14.4408 + Object a4, Object a5, Object a6, Object a7,
14.4409 + Object a8, Object a9, Object a10, Object a11,
14.4410 + Object a12, Object a13, Object a14, Object a15,
14.4411 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4412 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4413 + a10, a11, a12, a13, a14, a15, a16),
14.4414 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4415 + protected Object invoke_F18(Object a0, Object a1, Object a2, Object a3,
14.4416 + Object a4, Object a5, Object a6, Object a7,
14.4417 + Object a8, Object a9, Object a10, Object a11,
14.4418 + Object a12, Object a13, Object a14, Object a15,
14.4419 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4420 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4421 + a10, a11, a12, a13, a14, a15, a16, a17),
14.4422 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4423 + protected Object invoke_F19(Object a0, Object a1, Object a2, Object a3,
14.4424 + Object a4, Object a5, Object a6, Object a7,
14.4425 + Object a8, Object a9, Object a10, Object a11,
14.4426 + Object a12, Object a13, Object a14, Object a15,
14.4427 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4428 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4429 + a10, a11, a12, a13, a14, a15, a16, a17, a18),
14.4430 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4431 + protected Object invoke_F20(Object a0, Object a1, Object a2, Object a3,
14.4432 + Object a4, Object a5, Object a6, Object a7,
14.4433 + Object a8, Object a9, Object a10, Object a11,
14.4434 + Object a12, Object a13, Object a14, Object a15,
14.4435 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4436 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19),
14.4437 + a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); }
14.4438 + protected Object invoke_C0(Object a0, Object a1, Object a2, Object a3,
14.4439 + Object a4, Object a5, Object a6, Object a7,
14.4440 + Object a8, Object a9, Object a10, Object a11,
14.4441 + Object a12, Object a13, Object a14, Object a15,
14.4442 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4443 + return target.invoke(filter.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4444 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4445 + protected Object invoke_C1(Object a0, Object a1, Object a2, Object a3,
14.4446 + Object a4, Object a5, Object a6, Object a7,
14.4447 + Object a8, Object a9, Object a10, Object a11,
14.4448 + Object a12, Object a13, Object a14, Object a15,
14.4449 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4450 + return target.invoke(a0, filter.invoke(a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4451 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4452 + protected Object invoke_C2(Object a0, Object a1, Object a2, Object a3,
14.4453 + Object a4, Object a5, Object a6, Object a7,
14.4454 + Object a8, Object a9, Object a10, Object a11,
14.4455 + Object a12, Object a13, Object a14, Object a15,
14.4456 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4457 + return target.invoke(a0, a1, filter.invoke(a2, a3, a4, a5, a6, a7, a8, a9,
14.4458 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4459 + protected Object invoke_C3(Object a0, Object a1, Object a2, Object a3,
14.4460 + Object a4, Object a5, Object a6, Object a7,
14.4461 + Object a8, Object a9, Object a10, Object a11,
14.4462 + Object a12, Object a13, Object a14, Object a15,
14.4463 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4464 + return target.invoke(a0, a1, a2, filter.invoke(a3, a4, a5, a6, a7, a8, a9,
14.4465 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4466 + protected Object invoke_C4(Object a0, Object a1, Object a2, Object a3,
14.4467 + Object a4, Object a5, Object a6, Object a7,
14.4468 + Object a8, Object a9, Object a10, Object a11,
14.4469 + Object a12, Object a13, Object a14, Object a15,
14.4470 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4471 + return target.invoke(a0, a1, a2, a3, filter.invoke(a4, a5, a6, a7, a8, a9,
14.4472 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4473 + protected Object invoke_C5(Object a0, Object a1, Object a2, Object a3,
14.4474 + Object a4, Object a5, Object a6, Object a7,
14.4475 + Object a8, Object a9, Object a10, Object a11,
14.4476 + Object a12, Object a13, Object a14, Object a15,
14.4477 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4478 + return target.invoke(a0, a1, a2, a3, a4, filter.invoke(a5, a6, a7, a8, a9,
14.4479 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4480 + protected Object invoke_C6(Object a0, Object a1, Object a2, Object a3,
14.4481 + Object a4, Object a5, Object a6, Object a7,
14.4482 + Object a8, Object a9, Object a10, Object a11,
14.4483 + Object a12, Object a13, Object a14, Object a15,
14.4484 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4485 + return target.invoke(a0, a1, a2, a3, a4, a5, filter.invoke(a6, a7, a8, a9,
14.4486 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4487 + protected Object invoke_C7(Object a0, Object a1, Object a2, Object a3,
14.4488 + Object a4, Object a5, Object a6, Object a7,
14.4489 + Object a8, Object a9, Object a10, Object a11,
14.4490 + Object a12, Object a13, Object a14, Object a15,
14.4491 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4492 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, filter.invoke(a7, a8, a9,
14.4493 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4494 + protected Object invoke_C8(Object a0, Object a1, Object a2, Object a3,
14.4495 + Object a4, Object a5, Object a6, Object a7,
14.4496 + Object a8, Object a9, Object a10, Object a11,
14.4497 + Object a12, Object a13, Object a14, Object a15,
14.4498 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4499 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, filter.invoke(a8, a9,
14.4500 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4501 + protected Object invoke_C9(Object a0, Object a1, Object a2, Object a3,
14.4502 + Object a4, Object a5, Object a6, Object a7,
14.4503 + Object a8, Object a9, Object a10, Object a11,
14.4504 + Object a12, Object a13, Object a14, Object a15,
14.4505 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4506 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, filter.invoke(a9,
14.4507 + a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4508 + protected Object invoke_C10(Object a0, Object a1, Object a2, Object a3,
14.4509 + Object a4, Object a5, Object a6, Object a7,
14.4510 + Object a8, Object a9, Object a10, Object a11,
14.4511 + Object a12, Object a13, Object a14, Object a15,
14.4512 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4513 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, filter.invoke(a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4514 + protected Object invoke_C11(Object a0, Object a1, Object a2, Object a3,
14.4515 + Object a4, Object a5, Object a6, Object a7,
14.4516 + Object a8, Object a9, Object a10, Object a11,
14.4517 + Object a12, Object a13, Object a14, Object a15,
14.4518 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4519 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4520 + a10, filter.invoke(a11, a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4521 + protected Object invoke_C12(Object a0, Object a1, Object a2, Object a3,
14.4522 + Object a4, Object a5, Object a6, Object a7,
14.4523 + Object a8, Object a9, Object a10, Object a11,
14.4524 + Object a12, Object a13, Object a14, Object a15,
14.4525 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4526 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4527 + a10, a11, filter.invoke(a12, a13, a14, a15, a16, a17, a18, a19)); }
14.4528 + protected Object invoke_C13(Object a0, Object a1, Object a2, Object a3,
14.4529 + Object a4, Object a5, Object a6, Object a7,
14.4530 + Object a8, Object a9, Object a10, Object a11,
14.4531 + Object a12, Object a13, Object a14, Object a15,
14.4532 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4533 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4534 + a10, a11, a12, filter.invoke(a13, a14, a15, a16, a17, a18, a19)); }
14.4535 + protected Object invoke_C14(Object a0, Object a1, Object a2, Object a3,
14.4536 + Object a4, Object a5, Object a6, Object a7,
14.4537 + Object a8, Object a9, Object a10, Object a11,
14.4538 + Object a12, Object a13, Object a14, Object a15,
14.4539 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4540 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4541 + a10, a11, a12, a13, filter.invoke(a14, a15, a16, a17, a18, a19)); }
14.4542 + protected Object invoke_C15(Object a0, Object a1, Object a2, Object a3,
14.4543 + Object a4, Object a5, Object a6, Object a7,
14.4544 + Object a8, Object a9, Object a10, Object a11,
14.4545 + Object a12, Object a13, Object a14, Object a15,
14.4546 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4547 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4548 + a10, a11, a12, a13, a14, filter.invoke(a15, a16, a17, a18, a19)); }
14.4549 + protected Object invoke_C16(Object a0, Object a1, Object a2, Object a3,
14.4550 + Object a4, Object a5, Object a6, Object a7,
14.4551 + Object a8, Object a9, Object a10, Object a11,
14.4552 + Object a12, Object a13, Object a14, Object a15,
14.4553 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4554 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4555 + a10, a11, a12, a13, a14, a15, filter.invoke(a16, a17, a18, a19)); }
14.4556 + protected Object invoke_C17(Object a0, Object a1, Object a2, Object a3,
14.4557 + Object a4, Object a5, Object a6, Object a7,
14.4558 + Object a8, Object a9, Object a10, Object a11,
14.4559 + Object a12, Object a13, Object a14, Object a15,
14.4560 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4561 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4562 + a10, a11, a12, a13, a14, a15, a16, filter.invoke(a17, a18, a19)); }
14.4563 + protected Object invoke_C18(Object a0, Object a1, Object a2, Object a3,
14.4564 + Object a4, Object a5, Object a6, Object a7,
14.4565 + Object a8, Object a9, Object a10, Object a11,
14.4566 + Object a12, Object a13, Object a14, Object a15,
14.4567 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4568 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4569 + a10, a11, a12, a13, a14, a15, a16, a17, filter.invoke(a18, a19)); }
14.4570 + protected Object invoke_C19(Object a0, Object a1, Object a2, Object a3,
14.4571 + Object a4, Object a5, Object a6, Object a7,
14.4572 + Object a8, Object a9, Object a10, Object a11,
14.4573 + Object a12, Object a13, Object a14, Object a15,
14.4574 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4575 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
14.4576 + a10, a11, a12, a13, a14, a15, a16, a17, a18, filter.invoke(a19)); }
14.4577 + protected Object invoke_C20(Object a0, Object a1, Object a2, Object a3,
14.4578 + Object a4, Object a5, Object a6, Object a7,
14.4579 + Object a8, Object a9, Object a10, Object a11,
14.4580 + Object a12, Object a13, Object a14, Object a15,
14.4581 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4582 + return target.invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, filter.invoke()); }
14.4583 + protected Object invoke_Y0(Object a0, Object a1, Object a2, Object a3,
14.4584 + Object a4, Object a5, Object a6, Object a7,
14.4585 + Object a8, Object a9, Object a10, Object a11,
14.4586 + Object a12, Object a13, Object a14, Object a15,
14.4587 + Object a16, Object a17, Object a18, Object a19) throws Throwable {
14.4588 + Object[] av = { a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19 };
14.4589 + filter.<void>invoke(av); // make the flyby
14.4590 + return target.invoke(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]); }
14.4591 + }
14.4592 +}
15.1 --- a/src/share/classes/sun/dyn/FilterOneArgument.java Tue Jan 05 10:40:44 2010 +0800
15.2 +++ b/src/share/classes/sun/dyn/FilterOneArgument.java Wed Jan 13 15:16:06 2010 -0800
15.3 @@ -27,7 +27,6 @@
15.4
15.5 import java.dyn.JavaMethodHandle;
15.6 import java.dyn.MethodHandle;
15.7 -import java.dyn.MethodHandles;
15.8 import java.dyn.MethodType;
15.9
15.10 /**
15.11 @@ -42,16 +41,21 @@
15.12 protected final MethodHandle filter; // Object -> Object
15.13 protected final MethodHandle target; // Object -> Object
15.14
15.15 - protected Object entryPoint(Object argument) {
15.16 - Object filteredArgument = filter.<Object>invoke(argument);
15.17 - return target.<Object>invoke(filteredArgument);
15.18 + @Override
15.19 + public String toString() {
15.20 + return target.toString();
15.21 }
15.22
15.23 - private static final MethodHandle entryPoint =
15.24 - MethodHandleImpl.IMPL_LOOKUP.findVirtual(FilterOneArgument.class, "entryPoint", MethodType.makeGeneric(1));
15.25 + protected Object invoke(Object argument) throws Throwable {
15.26 + Object filteredArgument = filter.invoke(argument);
15.27 + return target.invoke(filteredArgument);
15.28 + }
15.29 +
15.30 + private static final MethodHandle INVOKE =
15.31 + MethodHandleImpl.IMPL_LOOKUP.findVirtual(FilterOneArgument.class, "invoke", MethodType.genericMethodType(1));
15.32
15.33 protected FilterOneArgument(MethodHandle filter, MethodHandle target) {
15.34 - super(entryPoint);
15.35 + super(INVOKE);
15.36 this.filter = filter;
15.37 this.target = target;
15.38 }
15.39 @@ -62,10 +66,6 @@
15.40 return new FilterOneArgument(filter, target);
15.41 }
15.42
15.43 - public String toString() {
15.44 - return filter + "|>" + target;
15.45 - }
15.46 -
15.47 // MethodHandle make(MethodHandle filter1, MethodHandle filter2, MethodHandle target) {
15.48 // MethodHandle filter = make(filter1, filter2);
15.49 // return make(filter, target);
16.1 --- a/src/share/classes/sun/dyn/FromGeneric.java Tue Jan 05 10:40:44 2010 +0800
16.2 +++ b/src/share/classes/sun/dyn/FromGeneric.java Wed Jan 13 15:16:06 2010 -0800
16.3 @@ -36,8 +36,8 @@
16.4 import sun.dyn.util.Wrapper;
16.5
16.6 /**
16.7 - * Adapters which mediate between incoming calls which are not generic
16.8 - * and outgoing calls which are. Any call can be represented generically
16.9 + * Adapters which mediate between incoming calls which are generic
16.10 + * and outgoing calls which are not. Any call can be represented generically
16.11 * boxing up its arguments, and (on return) unboxing the return value.
16.12 * <p>
16.13 * A call is "generic" (in MethodHandle terms) if its MethodType features
16.14 @@ -50,9 +50,6 @@
16.15 * either binds internally or else takes as a leading argument).
16.16 * (To stretch the term, adapter-like method handles may have multiple
16.17 * targets or be polymorphic across multiple call types.)
16.18 - * <p>
16.19 - * This adapter can sometimes be more directly implemented
16.20 - * by the JVM's built-in OP_SPREAD_ARGS adapter.
16.21 * @author jrose
16.22 */
16.23 class FromGeneric {
16.24 @@ -99,7 +96,7 @@
16.25 }
16.26 this.internalType = internalType0;
16.27 this.adapter = ad;
16.28 - MethodType tepType = targetType.insertParameterType(0, adapter.getClass());
16.29 + MethodType tepType = targetType.insertParameterTypes(0, adapter.getClass());
16.30 this.entryPoint = ad.prototypeEntryPoint();
16.31 this.returnConversion = computeReturnConversion(targetType, internalType0);
16.32 this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
16.33 @@ -146,7 +143,7 @@
16.34 if (fixArgs == null)
16.35 throw new InternalError("bad fixArgs");
16.36 // reinterpret the calling sequence as raw:
16.37 - MethodHandle retyper = AdapterMethodHandle.makeRawRetypeOnly(Access.TOKEN,
16.38 + MethodHandle retyper = AdapterMethodHandle.makeRetypeRaw(Access.TOKEN,
16.39 Invokers.invokerType(internalType), fixArgs);
16.40 if (retyper == null)
16.41 throw new InternalError("bad retyper");
16.42 @@ -226,7 +223,10 @@
16.43 // Produce an instance configured as a prototype.
16.44 return ctor.newInstance(entryPoint);
16.45 } catch (IllegalArgumentException ex) {
16.46 - } catch (InvocationTargetException ex) {
16.47 + } catch (InvocationTargetException wex) {
16.48 + Throwable ex = wex.getTargetException();
16.49 + if (ex instanceof Error) throw (Error)ex;
16.50 + if (ex instanceof RuntimeException) throw (RuntimeException)ex;
16.51 } catch (InstantiationException ex) {
16.52 } catch (IllegalAccessException ex) {
16.53 }
16.54 @@ -260,6 +260,11 @@
16.55 protected final MethodHandle convert; // raw(R) => Object
16.56 protected final MethodHandle target; // (any**N) => R
16.57
16.58 + @Override
16.59 + public String toString() {
16.60 + return target.toString();
16.61 + }
16.62 +
16.63 protected boolean isPrototype() { return target == null; }
16.64 protected Adapter(MethodHandle entryPoint) {
16.65 this(entryPoint, null, entryPoint, null);
16.66 @@ -284,11 +289,11 @@
16.67 // { return new ThisType(entryPoint, convert, target); }
16.68
16.69 /// Conversions on the value returned from the target.
16.70 - protected Object convert_L(Object result) { return convert.<Object>invoke(result); }
16.71 - protected Object convert_I(int result) { return convert.<Object>invoke(result); }
16.72 - protected Object convert_J(long result) { return convert.<Object>invoke(result); }
16.73 - protected Object convert_F(float result) { return convert.<Object>invoke(result); }
16.74 - protected Object convert_D(double result) { return convert.<Object>invoke(result); }
16.75 + protected Object convert_L(Object result) throws Throwable { return convert.<Object>invoke(result); }
16.76 + protected Object convert_I(int result) throws Throwable { return convert.<Object>invoke(result); }
16.77 + protected Object convert_J(long result) throws Throwable { return convert.<Object>invoke(result); }
16.78 + protected Object convert_F(float result) throws Throwable { return convert.<Object>invoke(result); }
16.79 + protected Object convert_D(double result) throws Throwable { return convert.<Object>invoke(result); }
16.80
16.81 static private final String CLASS_PREFIX; // "sun.dyn.FromGeneric$"
16.82 static {
16.83 @@ -317,11 +322,11 @@
16.84 { super(e, i, c, t); }
16.85 protected xA2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.86 { return new xA2(e, i, c, t); }
16.87 - protected Object invoke_L2(Object a0, Object a1) { return convert_L(invoker.<Object>invoke(target, a0, a1)); }
16.88 - protected Object invoke_I2(Object a0, Object a1) { return convert_I(invoker.<int >invoke(target, a0, a1)); }
16.89 - protected Object invoke_J2(Object a0, Object a1) { return convert_J(invoker.<long >invoke(target, a0, a1)); }
16.90 - protected Object invoke_F2(Object a0, Object a1) { return convert_F(invoker.<float >invoke(target, a0, a1)); }
16.91 - protected Object invoke_D2(Object a0, Object a1) { return convert_D(invoker.<double>invoke(target, a0, a1)); }
16.92 + protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1)); }
16.93 + protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1)); }
16.94 + protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1)); }
16.95 + protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1)); }
16.96 + protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1)); }
16.97 }
16.98 // */
16.99
16.100 @@ -342,7 +347,7 @@
16.101 " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
16.102 " { return new @cat@(e, i, c, t); }",
16.103 " //@each-R@",
16.104 - " protected Object invoke_@catN@(@Tvav@) { return convert_@Rc@(invoker.<@R@>invoke(target@av@)); }",
16.105 + " protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@(invoker.<@R@>invoke(target@av@)); }",
16.106 " //@end-R@",
16.107 " }",
16.108 } };
16.109 @@ -498,11 +503,11 @@
16.110 { super(e, i, c, t); }
16.111 protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.112 { return new A0(e, i, c, t); }
16.113 - protected Object invoke_L0() { return convert_L(invoker.<Object>invoke(target)); }
16.114 - protected Object invoke_I0() { return convert_I(invoker.<int >invoke(target)); }
16.115 - protected Object invoke_J0() { return convert_J(invoker.<long >invoke(target)); }
16.116 - protected Object invoke_F0() { return convert_F(invoker.<float >invoke(target)); }
16.117 - protected Object invoke_D0() { return convert_D(invoker.<double>invoke(target)); }
16.118 + protected Object invoke_L0() throws Throwable { return convert_L(invoker.<Object>invoke(target)); }
16.119 + protected Object invoke_I0() throws Throwable { return convert_I(invoker.<int >invoke(target)); }
16.120 + protected Object invoke_J0() throws Throwable { return convert_J(invoker.<long >invoke(target)); }
16.121 + protected Object invoke_F0() throws Throwable { return convert_F(invoker.<float >invoke(target)); }
16.122 + protected Object invoke_D0() throws Throwable { return convert_D(invoker.<double>invoke(target)); }
16.123 }
16.124 static class A1 extends Adapter {
16.125 protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.126 @@ -510,11 +515,11 @@
16.127 { super(e, i, c, t); }
16.128 protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.129 { return new A1(e, i, c, t); }
16.130 - protected Object invoke_L1(Object a0) { return convert_L(invoker.<Object>invoke(target, a0)); }
16.131 - protected Object invoke_I1(Object a0) { return convert_I(invoker.<int >invoke(target, a0)); }
16.132 - protected Object invoke_J1(Object a0) { return convert_J(invoker.<long >invoke(target, a0)); }
16.133 - protected Object invoke_F1(Object a0) { return convert_F(invoker.<float >invoke(target, a0)); }
16.134 - protected Object invoke_D1(Object a0) { return convert_D(invoker.<double>invoke(target, a0)); }
16.135 + protected Object invoke_L1(Object a0) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0)); }
16.136 + protected Object invoke_I1(Object a0) throws Throwable { return convert_I(invoker.<int >invoke(target, a0)); }
16.137 + protected Object invoke_J1(Object a0) throws Throwable { return convert_J(invoker.<long >invoke(target, a0)); }
16.138 + protected Object invoke_F1(Object a0) throws Throwable { return convert_F(invoker.<float >invoke(target, a0)); }
16.139 + protected Object invoke_D1(Object a0) throws Throwable { return convert_D(invoker.<double>invoke(target, a0)); }
16.140 }
16.141 static class A2 extends Adapter {
16.142 protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.143 @@ -522,11 +527,11 @@
16.144 { super(e, i, c, t); }
16.145 protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.146 { return new A2(e, i, c, t); }
16.147 - protected Object invoke_L2(Object a0, Object a1) { return convert_L(invoker.<Object>invoke(target, a0, a1)); }
16.148 - protected Object invoke_I2(Object a0, Object a1) { return convert_I(invoker.<int >invoke(target, a0, a1)); }
16.149 - protected Object invoke_J2(Object a0, Object a1) { return convert_J(invoker.<long >invoke(target, a0, a1)); }
16.150 - protected Object invoke_F2(Object a0, Object a1) { return convert_F(invoker.<float >invoke(target, a0, a1)); }
16.151 - protected Object invoke_D2(Object a0, Object a1) { return convert_D(invoker.<double>invoke(target, a0, a1)); }
16.152 + protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1)); }
16.153 + protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1)); }
16.154 + protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1)); }
16.155 + protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1)); }
16.156 + protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1)); }
16.157 }
16.158 static class A3 extends Adapter {
16.159 protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.160 @@ -534,11 +539,11 @@
16.161 { super(e, i, c, t); }
16.162 protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.163 { return new A3(e, i, c, t); }
16.164 - protected Object invoke_L3(Object a0, Object a1, Object a2) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2)); }
16.165 - protected Object invoke_I3(Object a0, Object a1, Object a2) { return convert_I(invoker.<int >invoke(target, a0, a1, a2)); }
16.166 - protected Object invoke_J3(Object a0, Object a1, Object a2) { return convert_J(invoker.<long >invoke(target, a0, a1, a2)); }
16.167 - protected Object invoke_F3(Object a0, Object a1, Object a2) { return convert_F(invoker.<float >invoke(target, a0, a1, a2)); }
16.168 - protected Object invoke_D3(Object a0, Object a1, Object a2) { return convert_D(invoker.<double>invoke(target, a0, a1, a2)); }
16.169 + protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1, a2)); }
16.170 + protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1, a2)); }
16.171 + protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1, a2)); }
16.172 + protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1, a2)); }
16.173 + protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1, a2)); }
16.174 }
16.175 static class A4 extends Adapter {
16.176 protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.177 @@ -546,11 +551,11 @@
16.178 { super(e, i, c, t); }
16.179 protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.180 { return new A4(e, i, c, t); }
16.181 - protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3)); }
16.182 - protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3)); }
16.183 - protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3)); }
16.184 - protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3)); }
16.185 - protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3)); }
16.186 + protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3)); }
16.187 + protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3)); }
16.188 + protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3)); }
16.189 + protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3)); }
16.190 + protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3)); }
16.191 }
16.192 static class A5 extends Adapter {
16.193 protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.194 @@ -558,11 +563,11 @@
16.195 { super(e, i, c, t); }
16.196 protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.197 { return new A5(e, i, c, t); }
16.198 - protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4)); }
16.199 - protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4)); }
16.200 - protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4)); }
16.201 - protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4)); }
16.202 - protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4)); }
16.203 + protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4)); }
16.204 + protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4)); }
16.205 + protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4)); }
16.206 + protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4)); }
16.207 + protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4)); }
16.208 }
16.209 static class A6 extends Adapter {
16.210 protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.211 @@ -570,11 +575,11 @@
16.212 { super(e, i, c, t); }
16.213 protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.214 { return new A6(e, i, c, t); }
16.215 - protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5)); }
16.216 - protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.217 - protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.218 - protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.219 - protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5)); }
16.220 + protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5)); }
16.221 + protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.222 + protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.223 + protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5)); }
16.224 + protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5)); }
16.225 }
16.226 static class A7 extends Adapter {
16.227 protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.228 @@ -582,11 +587,11 @@
16.229 { super(e, i, c, t); }
16.230 protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.231 { return new A7(e, i, c, t); }
16.232 - protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.233 - protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.234 - protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.235 - protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.236 - protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.237 + protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.238 + protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.239 + protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.240 + protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.241 + protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6)); }
16.242 }
16.243 static class A8 extends Adapter {
16.244 protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.245 @@ -594,11 +599,11 @@
16.246 { super(e, i, c, t); }
16.247 protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.248 { return new A8(e, i, c, t); }
16.249 - protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.250 - protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.251 - protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.252 - protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.253 - protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.254 + 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(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.255 + 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(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.256 + 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(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.257 + 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(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.258 + 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(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
16.259 }
16.260 static class A9 extends Adapter {
16.261 protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.262 @@ -606,11 +611,11 @@
16.263 { super(e, i, c, t); }
16.264 protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.265 { return new A9(e, i, c, t); }
16.266 - protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.267 - protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.268 - protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.269 - protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.270 - protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.271 + 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(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.272 + 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(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.273 + 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(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.274 + 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(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.275 + 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(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
16.276 }
16.277 static class A10 extends Adapter {
16.278 protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
16.279 @@ -618,10 +623,10 @@
16.280 { super(e, i, c, t); }
16.281 protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
16.282 { return new A10(e, i, c, t); }
16.283 - protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return convert_L(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.284 - protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return convert_I(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.285 - protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return convert_J(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.286 - protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return convert_F(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.287 - protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return convert_D(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.288 + 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(invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.289 + 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(invoker.<int >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.290 + 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(invoker.<long >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.291 + 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(invoker.<float >invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.292 + 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(invoker.<double>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
16.293 }
16.294 }
17.1 --- a/src/share/classes/sun/dyn/Invokers.java Tue Jan 05 10:40:44 2010 +0800
17.2 +++ b/src/share/classes/sun/dyn/Invokers.java Wed Jan 13 15:16:06 2010 -0800
17.3 @@ -44,16 +44,20 @@
17.4 // generic (untyped) invoker for the outgoing call
17.5 private /*lazy*/ MethodHandle genericInvoker;
17.6
17.7 + // generic (untyped) invoker for the outgoing call; accepts a single Object[]
17.8 + private final /*lazy*/ MethodHandle[] varargsInvokers;
17.9 +
17.10 /** Compute and cache information common to all collecting adapters
17.11 * that implement members of the erasure-family of the given erased type.
17.12 */
17.13 public Invokers(Access token, MethodType targetType) {
17.14 Access.check(token);
17.15 this.targetType = targetType;
17.16 + this.varargsInvokers = new MethodHandle[targetType.parameterCount()+1];
17.17 }
17.18
17.19 public static MethodType invokerType(MethodType targetType) {
17.20 - return targetType.insertParameterType(0, MethodHandle.class);
17.21 + return targetType.insertParameterTypes(0, MethodHandle.class);
17.22 }
17.23
17.24 public MethodHandle exactInvoker() {
17.25 @@ -76,8 +80,14 @@
17.26 return invoker;
17.27 }
17.28
17.29 - public MethodHandle varargsInvoker() {
17.30 - throw new UnsupportedOperationException("NYI");
17.31 + public MethodHandle varargsInvoker(int objectArgCount) {
17.32 + MethodHandle vaInvoker = varargsInvokers[objectArgCount];
17.33 + if (vaInvoker != null) return vaInvoker;
17.34 + MethodHandle gInvoker = genericInvoker();
17.35 + MethodType vaType = MethodType.genericMethodType(objectArgCount, true);
17.36 + vaInvoker = MethodHandles.spreadArguments(gInvoker, invokerType(vaType));
17.37 + varargsInvokers[objectArgCount] = vaInvoker;
17.38 + return vaInvoker;
17.39 }
17.40
17.41 public String toString() {
18.1 --- a/src/share/classes/sun/dyn/MemberName.java Tue Jan 05 10:40:44 2010 +0800
18.2 +++ b/src/share/classes/sun/dyn/MemberName.java Wed Jan 13 15:16:06 2010 -0800
18.3 @@ -25,7 +25,7 @@
18.4
18.5 package sun.dyn;
18.6
18.7 -import sun.dyn.util.BytecodeSignature;
18.8 +import sun.dyn.util.BytecodeDescriptor;
18.9 import java.dyn.*;
18.10 import java.lang.reflect.Constructor;
18.11 import java.lang.reflect.Field;
18.12 @@ -33,6 +33,7 @@
18.13 import java.lang.reflect.Member;
18.14 import java.lang.reflect.Modifier;
18.15 import java.util.ArrayList;
18.16 +import java.util.Arrays;
18.17 import java.util.Collections;
18.18 import java.util.Iterator;
18.19 import java.util.List;
18.20 @@ -93,7 +94,7 @@
18.21 }
18.22 if (type instanceof String) {
18.23 String sig = (String) type;
18.24 - MethodType res = MethodType.fromBytecodeString(sig, getClassLoader());
18.25 + MethodType res = MethodType.fromMethodDescriptorString(sig, getClassLoader());
18.26 this.type = res;
18.27 return res;
18.28 }
18.29 @@ -101,7 +102,7 @@
18.30 Object[] typeInfo = (Object[]) type;
18.31 Class<?>[] ptypes = (Class<?>[]) typeInfo[1];
18.32 Class<?> rtype = (Class<?>) typeInfo[0];
18.33 - MethodType res = MethodType.make(rtype, ptypes);
18.34 + MethodType res = MethodType.methodType(rtype, ptypes);
18.35 this.type = res;
18.36 return res;
18.37 }
18.38 @@ -111,7 +112,7 @@
18.39 public MethodType getInvocationType() {
18.40 MethodType itype = getMethodType();
18.41 if (!isStatic())
18.42 - itype = itype.insertParameterType(0, clazz);
18.43 + itype = itype.insertParameterTypes(0, clazz);
18.44 return itype;
18.45 }
18.46
18.47 @@ -135,7 +136,7 @@
18.48 }
18.49 if (type instanceof String) {
18.50 String sig = (String) type;
18.51 - MethodType mtype = MethodType.fromBytecodeString("()"+sig, getClassLoader());
18.52 + MethodType mtype = MethodType.fromMethodDescriptorString("()"+sig, getClassLoader());
18.53 Class<?> res = mtype.returnType();
18.54 this.type = res;
18.55 return res;
18.56 @@ -155,9 +156,9 @@
18.57 if (type instanceof String)
18.58 return (String) type;
18.59 if (isInvocable())
18.60 - return BytecodeSignature.unparse(getMethodType());
18.61 + return BytecodeDescriptor.unparse(getMethodType());
18.62 else
18.63 - return BytecodeSignature.unparse(getFieldType());
18.64 + return BytecodeDescriptor.unparse(getFieldType());
18.65 }
18.66
18.67 public int getModifiers() {
18.68 @@ -353,6 +354,8 @@
18.69 return type.toString(); // class java.lang.String
18.70 // else it is a field, method, or constructor
18.71 StringBuilder buf = new StringBuilder();
18.72 + if (!isResolved())
18.73 + buf.append("*.");
18.74 if (getDeclaringClass() != null) {
18.75 buf.append(getName(clazz));
18.76 buf.append('.');
18.77 @@ -381,7 +384,7 @@
18.78 private static String getName(Object obj) {
18.79 if (obj instanceof Class<?>)
18.80 return ((Class<?>)obj).getName();
18.81 - return obj.toString();
18.82 + return String.valueOf(obj);
18.83 }
18.84
18.85 // Queries to the JVM:
18.86 @@ -408,6 +411,9 @@
18.87 public static NoAccessException newNoAccessException(MemberName name, Class<?> lookupClass) {
18.88 return newNoAccessException("cannot access", name, lookupClass);
18.89 }
18.90 + public static NoAccessException newNoAccessException(MemberName name, MethodHandles.Lookup lookup) {
18.91 + return newNoAccessException(name, lookup.lookupClass());
18.92 + }
18.93 public static NoAccessException newNoAccessException(String message,
18.94 MemberName name, Class<?> lookupClass) {
18.95 message += ": " + name;
18.96 @@ -436,7 +442,7 @@
18.97 matchFlags &= ALLOWED_FLAGS;
18.98 String matchSig = null;
18.99 if (matchType != null) {
18.100 - matchSig = BytecodeSignature.unparse(matchType);
18.101 + matchSig = BytecodeDescriptor.unparse(matchType);
18.102 if (matchSig.startsWith("("))
18.103 matchFlags &= ~(ALL_KINDS & ~IS_INVOCABLE);
18.104 else
18.105 @@ -447,17 +453,18 @@
18.106 MemberName[] buf = newMemberBuffer(len1);
18.107 int totalCount = 0;
18.108 ArrayList<MemberName[]> bufs = null;
18.109 + int bufCount = 0;
18.110 for (;;) {
18.111 - int bufCount = MethodHandleNatives.getMembers(defc,
18.112 + bufCount = MethodHandleNatives.getMembers(defc,
18.113 matchName, matchSig, matchFlags,
18.114 lookupClass,
18.115 totalCount, buf);
18.116 if (bufCount <= buf.length) {
18.117 - if (bufCount >= 0)
18.118 - totalCount += bufCount;
18.119 + if (bufCount < 0) bufCount = 0;
18.120 + totalCount += bufCount;
18.121 break;
18.122 }
18.123 - // JVM returned tp us with an intentional overflow!
18.124 + // JVM returned to us with an intentional overflow!
18.125 totalCount += buf.length;
18.126 int excess = bufCount - buf.length;
18.127 if (bufs == null) bufs = new ArrayList<MemberName[]>(1);
18.128 @@ -473,7 +480,7 @@
18.129 Collections.addAll(result, buf0);
18.130 }
18.131 }
18.132 - Collections.addAll(result, buf);
18.133 + result.addAll(Arrays.asList(buf).subList(0, bufCount));
18.134 // Signature matching is not the same as type matching, since
18.135 // one signature might correspond to several types.
18.136 // So if matchType is a Class or MethodType, refilter the results.
19.1 --- a/src/share/classes/sun/dyn/MethodHandleImpl.java Tue Jan 05 10:40:44 2010 +0800
19.2 +++ b/src/share/classes/sun/dyn/MethodHandleImpl.java Wed Jan 13 15:16:06 2010 -0800
19.3 @@ -25,12 +25,25 @@
19.4
19.5 package sun.dyn;
19.6
19.7 +import java.dyn.JavaMethodHandle;
19.8 import java.dyn.MethodHandle;
19.9 import java.dyn.MethodHandles;
19.10 import java.dyn.MethodHandles.Lookup;
19.11 import java.dyn.MethodType;
19.12 +import java.util.logging.Level;
19.13 +import java.util.logging.Logger;
19.14 import sun.dyn.util.VerifyType;
19.15 import java.dyn.NoAccessException;
19.16 +import java.util.ArrayList;
19.17 +import java.util.Arrays;
19.18 +import java.util.Collections;
19.19 +import java.util.HashMap;
19.20 +import java.util.Iterator;
19.21 +import java.util.List;
19.22 +import sun.dyn.empty.Empty;
19.23 +import sun.dyn.util.ValueConversions;
19.24 +import sun.dyn.util.Wrapper;
19.25 +import sun.misc.Unsafe;
19.26 import static sun.dyn.MemberName.newIllegalArgumentException;
19.27 import static sun.dyn.MemberName.newNoAccessException;
19.28
19.29 @@ -57,6 +70,25 @@
19.30 static final int INT_FIELD = 0;
19.31 static final long LONG_FIELD = 0;
19.32
19.33 + /** Access methods for the internals of MethodHandle, supplied to
19.34 + * MethodHandleImpl as a trusted agent.
19.35 + */
19.36 + static public interface MethodHandleFriend {
19.37 + void initType(MethodHandle mh, MethodType type);
19.38 + }
19.39 + public static void setMethodHandleFriend(Access token, MethodHandleFriend am) {
19.40 + Access.check(token);
19.41 + if (METHOD_HANDLE_FRIEND != null)
19.42 + throw new InternalError(); // just once
19.43 + METHOD_HANDLE_FRIEND = am;
19.44 + }
19.45 + static private MethodHandleFriend METHOD_HANDLE_FRIEND;
19.46 +
19.47 + // NOT public
19.48 + static void initType(MethodHandle mh, MethodType type) {
19.49 + METHOD_HANDLE_FRIEND.initType(mh, type);
19.50 + }
19.51 +
19.52 // type is defined in java.dyn.MethodHandle, which is platform-independent
19.53
19.54 // vmentry (a void* field) is used *only* by by the JVM.
19.55 @@ -106,8 +138,8 @@
19.56 }
19.57
19.58 static {
19.59 - // Force initialization:
19.60 - Lookup.PUBLIC_LOOKUP.lookupClass();
19.61 + // Force initialization of Lookup, so it calls us back as initLookup:
19.62 + MethodHandles.publicLookup();
19.63 if (IMPL_LOOKUP_INIT == null)
19.64 throw new InternalError();
19.65 }
19.66 @@ -151,7 +183,7 @@
19.67 // adjust the advertised receiver type to be exactly the one requested
19.68 // (in the case of invokespecial, this will be the calling class)
19.69 Class<?> recvType = method.getDeclaringClass();
19.70 - mtype = mtype.insertParameterType(0, recvType);
19.71 + mtype = mtype.insertParameterTypes(0, recvType);
19.72 if (method.isConstructor())
19.73 doDispatch = true;
19.74 // FIXME: JVM has trouble building MH.invoke sites for
19.75 @@ -170,21 +202,223 @@
19.76
19.77 public static
19.78 MethodHandle accessField(Access token,
19.79 - MemberName member, boolean isSetter,
19.80 - Class<?> lookupClass) {
19.81 + MemberName member, boolean isSetter,
19.82 + Class<?> lookupClass) {
19.83 Access.check(token);
19.84 - // FIXME: Use sun.misc.Unsafe to dig up the dirt on the field.
19.85 - throw new UnsupportedOperationException("Not yet implemented");
19.86 + // Use sun. misc.Unsafe to dig up the dirt on the field.
19.87 + MethodHandle mh = new FieldAccessor(token, member, isSetter);
19.88 + return mh;
19.89 }
19.90
19.91 public static
19.92 MethodHandle accessArrayElement(Access token,
19.93 - Class<?> arrayClass, boolean isSetter) {
19.94 + Class<?> arrayClass, boolean isSetter) {
19.95 Access.check(token);
19.96 if (!arrayClass.isArray())
19.97 throw newIllegalArgumentException("not an array: "+arrayClass);
19.98 - // FIXME: Use sun.misc.Unsafe to dig up the dirt on the array.
19.99 - throw new UnsupportedOperationException("Not yet implemented");
19.100 + Class<?> elemClass = arrayClass.getComponentType();
19.101 + MethodHandle[] mhs = FieldAccessor.ARRAY_CACHE.get(elemClass);
19.102 + if (mhs == null) {
19.103 + if (!FieldAccessor.doCache(elemClass))
19.104 + return FieldAccessor.ahandle(arrayClass, isSetter);
19.105 + mhs = new MethodHandle[] {
19.106 + FieldAccessor.ahandle(arrayClass, false),
19.107 + FieldAccessor.ahandle(arrayClass, true)
19.108 + };
19.109 + if (mhs[0].type().parameterType(0) == Class.class) {
19.110 + mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);
19.111 + mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);
19.112 + }
19.113 + synchronized (FieldAccessor.ARRAY_CACHE) {} // memory barrier
19.114 + FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);
19.115 + }
19.116 + return mhs[isSetter ? 1 : 0];
19.117 + }
19.118 +
19.119 + static final class FieldAccessor<C,V> extends JavaMethodHandle {
19.120 + private static final Unsafe unsafe = Unsafe.getUnsafe();
19.121 + final Object base; // for static refs only
19.122 + final long offset;
19.123 + final String name;
19.124 +
19.125 + public FieldAccessor(Access token, MemberName field, boolean isSetter) {
19.126 + super(fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));
19.127 + this.offset = (long) field.getVMIndex(token);
19.128 + this.name = field.getName();
19.129 + this.base = staticBase(field);
19.130 + }
19.131 + public String toString() { return name; }
19.132 +
19.133 + int getFieldI(C obj) { return unsafe.getInt(obj, offset); }
19.134 + void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); }
19.135 + long getFieldJ(C obj) { return unsafe.getLong(obj, offset); }
19.136 + void setFieldJ(C obj, long x) { unsafe.putLong(obj, offset, x); }
19.137 + float getFieldF(C obj) { return unsafe.getFloat(obj, offset); }
19.138 + void setFieldF(C obj, float x) { unsafe.putFloat(obj, offset, x); }
19.139 + double getFieldD(C obj) { return unsafe.getDouble(obj, offset); }
19.140 + void setFieldD(C obj, double x) { unsafe.putDouble(obj, offset, x); }
19.141 + boolean getFieldZ(C obj) { return unsafe.getBoolean(obj, offset); }
19.142 + void setFieldZ(C obj, boolean x) { unsafe.putBoolean(obj, offset, x); }
19.143 + byte getFieldB(C obj) { return unsafe.getByte(obj, offset); }
19.144 + void setFieldB(C obj, byte x) { unsafe.putByte(obj, offset, x); }
19.145 + short getFieldS(C obj) { return unsafe.getShort(obj, offset); }
19.146 + void setFieldS(C obj, short x) { unsafe.putShort(obj, offset, x); }
19.147 + char getFieldC(C obj) { return unsafe.getChar(obj, offset); }
19.148 + void setFieldC(C obj, char x) { unsafe.putChar(obj, offset, x); }
19.149 + @SuppressWarnings("unchecked")
19.150 + V getFieldL(C obj) { return (V) unsafe.getObject(obj, offset); }
19.151 + @SuppressWarnings("unchecked")
19.152 + void setFieldL(C obj, V x) { unsafe.putObject(obj, offset, x); }
19.153 + // cast (V) is OK here, since we wrap convertArguments around the MH.
19.154 +
19.155 + static Object staticBase(MemberName field) {
19.156 + if (!field.isStatic()) return null;
19.157 + Class c = field.getDeclaringClass();
19.158 + java.lang.reflect.Field f;
19.159 + try {
19.160 + // FIXME: Should not have to create 'f' to get this value.
19.161 + f = c.getDeclaredField(field.getName());
19.162 + return unsafe.staticFieldBase(f);
19.163 + } catch (Exception ee) {
19.164 + Error e = new InternalError();
19.165 + e.initCause(ee);
19.166 + throw e;
19.167 + }
19.168 + }
19.169 +
19.170 + int getStaticI() { return unsafe.getInt(base, offset); }
19.171 + void setStaticI(int x) { unsafe.putInt(base, offset, x); }
19.172 + long getStaticJ() { return unsafe.getLong(base, offset); }
19.173 + void setStaticJ(long x) { unsafe.putLong(base, offset, x); }
19.174 + float getStaticF() { return unsafe.getFloat(base, offset); }
19.175 + void setStaticF(float x) { unsafe.putFloat(base, offset, x); }
19.176 + double getStaticD() { return unsafe.getDouble(base, offset); }
19.177 + void setStaticD(double x) { unsafe.putDouble(base, offset, x); }
19.178 + boolean getStaticZ() { return unsafe.getBoolean(base, offset); }
19.179 + void setStaticZ(boolean x) { unsafe.putBoolean(base, offset, x); }
19.180 + byte getStaticB() { return unsafe.getByte(base, offset); }
19.181 + void setStaticB(byte x) { unsafe.putByte(base, offset, x); }
19.182 + short getStaticS() { return unsafe.getShort(base, offset); }
19.183 + void setStaticS(short x) { unsafe.putShort(base, offset, x); }
19.184 + char getStaticC() { return unsafe.getChar(base, offset); }
19.185 + void setStaticC(char x) { unsafe.putChar(base, offset, x); }
19.186 + V getStaticL() { return (V) unsafe.getObject(base, offset); }
19.187 + void setStaticL(V x) { unsafe.putObject(base, offset, x); }
19.188 +
19.189 + static String fname(Class<?> vclass, boolean isSetter, boolean isStatic) {
19.190 + String stem;
19.191 + if (!isStatic)
19.192 + stem = (!isSetter ? "getField" : "setField");
19.193 + else
19.194 + stem = (!isSetter ? "getStatic" : "setStatic");
19.195 + return stem + Wrapper.basicTypeChar(vclass);
19.196 + }
19.197 + static MethodType ftype(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
19.198 + MethodType type;
19.199 + if (!isStatic) {
19.200 + if (!isSetter)
19.201 + return MethodType.methodType(vclass, cclass);
19.202 + else
19.203 + return MethodType.methodType(void.class, cclass, vclass);
19.204 + } else {
19.205 + if (!isSetter)
19.206 + return MethodType.methodType(vclass);
19.207 + else
19.208 + return MethodType.methodType(void.class, vclass);
19.209 + }
19.210 + }
19.211 + static MethodHandle fhandle(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {
19.212 + String name = FieldAccessor.fname(vclass, isSetter, isStatic);
19.213 + if (cclass.isPrimitive()) throw newIllegalArgumentException("primitive "+cclass);
19.214 + Class<?> ecclass = Object.class; //erase this type
19.215 + Class<?> evclass = vclass;
19.216 + if (!evclass.isPrimitive()) evclass = Object.class;
19.217 + MethodType type = FieldAccessor.ftype(ecclass, evclass, isSetter, isStatic);
19.218 + MethodHandle mh;
19.219 + try {
19.220 + mh = IMPL_LOOKUP.findVirtual(FieldAccessor.class, name, type);
19.221 + } catch (NoAccessException ee) {
19.222 + Error e = new InternalError("name,type="+name+type);
19.223 + e.initCause(ee);
19.224 + throw e;
19.225 + }
19.226 + if (evclass != vclass || (!isStatic && ecclass != cclass)) {
19.227 + MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);
19.228 + strongType = strongType.insertParameterTypes(0, FieldAccessor.class);
19.229 + mh = MethodHandles.convertArguments(mh, strongType);
19.230 + }
19.231 + return mh;
19.232 + }
19.233 +
19.234 + /// Support for array element access
19.235 + static final HashMap<Class<?>, MethodHandle[]> ARRAY_CACHE =
19.236 + new HashMap<Class<?>, MethodHandle[]>();
19.237 + // FIXME: Cache on the classes themselves, not here.
19.238 + static boolean doCache(Class<?> elemClass) {
19.239 + if (elemClass.isPrimitive()) return true;
19.240 + ClassLoader cl = elemClass.getClassLoader();
19.241 + return cl == null || cl == ClassLoader.getSystemClassLoader();
19.242 + }
19.243 + static int getElementI(int[] a, int i) { return a[i]; }
19.244 + static void setElementI(int[] a, int i, int x) { a[i] = x; }
19.245 + static long getElementJ(long[] a, int i) { return a[i]; }
19.246 + static void setElementJ(long[] a, int i, long x) { a[i] = x; }
19.247 + static float getElementF(float[] a, int i) { return a[i]; }
19.248 + static void setElementF(float[] a, int i, float x) { a[i] = x; }
19.249 + static double getElementD(double[] a, int i) { return a[i]; }
19.250 + static void setElementD(double[] a, int i, double x) { a[i] = x; }
19.251 + static boolean getElementZ(boolean[] a, int i) { return a[i]; }
19.252 + static void setElementZ(boolean[] a, int i, boolean x) { a[i] = x; }
19.253 + static byte getElementB(byte[] a, int i) { return a[i]; }
19.254 + static void setElementB(byte[] a, int i, byte x) { a[i] = x; }
19.255 + static short getElementS(short[] a, int i) { return a[i]; }
19.256 + static void setElementS(short[] a, int i, short x) { a[i] = x; }
19.257 + static char getElementC(char[] a, int i) { return a[i]; }
19.258 + static void setElementC(char[] a, int i, char x) { a[i] = x; }
19.259 + static Object getElementL(Object[] a, int i) { return a[i]; }
19.260 + static void setElementL(Object[] a, int i, Object x) { a[i] = x; }
19.261 + static <V> V getElementL(Class<V[]> aclass, V[] a, int i) { return aclass.cast(a)[i]; }
19.262 + static <V> void setElementL(Class<V[]> aclass, V[] a, int i, V x) { aclass.cast(a)[i] = x; }
19.263 +
19.264 + static String aname(Class<?> aclass, boolean isSetter) {
19.265 + Class<?> vclass = aclass.getComponentType();
19.266 + if (vclass == null) throw new IllegalArgumentException();
19.267 + return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(vclass);
19.268 + }
19.269 + static MethodType atype(Class<?> aclass, boolean isSetter) {
19.270 + Class<?> vclass = aclass.getComponentType();
19.271 + if (!isSetter)
19.272 + return MethodType.methodType(vclass, aclass, int.class);
19.273 + else
19.274 + return MethodType.methodType(void.class, aclass, int.class, vclass);
19.275 + }
19.276 + static MethodHandle ahandle(Class<?> aclass, boolean isSetter) {
19.277 + Class<?> vclass = aclass.getComponentType();
19.278 + String name = FieldAccessor.aname(aclass, isSetter);
19.279 + Class<?> caclass = null;
19.280 + if (!vclass.isPrimitive() && vclass != Object.class) {
19.281 + caclass = aclass;
19.282 + aclass = Object[].class;
19.283 + vclass = Object.class;
19.284 + }
19.285 + MethodType type = FieldAccessor.atype(aclass, isSetter);
19.286 + if (caclass != null)
19.287 + type = type.insertParameterTypes(0, Class.class);
19.288 + MethodHandle mh;
19.289 + try {
19.290 + mh = IMPL_LOOKUP.findStatic(FieldAccessor.class, name, type);
19.291 + } catch (NoAccessException ee) {
19.292 + Error e = new InternalError("name,type="+name+type);
19.293 + e.initCause(ee);
19.294 + throw e;
19.295 + }
19.296 + if (caclass != null) {
19.297 + MethodType strongType = FieldAccessor.atype(caclass, isSetter);
19.298 + mh = MethodHandles.insertArguments(mh, 0, caclass);
19.299 + mh = MethodHandles.convertArguments(mh, strongType);
19.300 + }
19.301 + return mh;
19.302 + }
19.303 }
19.304
19.305 /** Bind a predetermined first argument to the given direct method handle.
19.306 @@ -203,8 +437,11 @@
19.307 if (info instanceof DirectMethodHandle) {
19.308 DirectMethodHandle dmh = (DirectMethodHandle) info;
19.309 if (receiver == null ||
19.310 - dmh.type().parameterType(0).isAssignableFrom(receiver.getClass()))
19.311 - target = dmh;
19.312 + dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {
19.313 + MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);
19.314 + MethodType newType = target.type().dropParameterTypes(0, 1);
19.315 + return convertArguments(token, bmh, newType, bmh.type(), null);
19.316 + }
19.317 }
19.318 }
19.319 if (target instanceof DirectMethodHandle)
19.320 @@ -223,7 +460,7 @@
19.321 MethodHandle bindArgument(Access token,
19.322 MethodHandle target, int argnum, Object receiver) {
19.323 Access.check(token);
19.324 - throw new UnsupportedOperationException("NYI");
19.325 + return new BoundMethodHandle(target, receiver, argnum);
19.326 }
19.327
19.328 public static MethodHandle convertArguments(Access token,
19.329 @@ -232,6 +469,189 @@
19.330 MethodType oldType,
19.331 int[] permutationOrNull) {
19.332 Access.check(token);
19.333 + if (permutationOrNull != null) {
19.334 + int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
19.335 + if (permutationOrNull.length != outargs)
19.336 + throw newIllegalArgumentException("wrong number of arguments in permutation");
19.337 + // Make the individual outgoing argument types match up first.
19.338 + Class<?>[] callTypeArgs = new Class<?>[outargs];
19.339 + for (int i = 0; i < outargs; i++)
19.340 + callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
19.341 + MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
19.342 + target = convertArguments(token, target, callType, oldType, null);
19.343 + assert(target != null);
19.344 + oldType = target.type();
19.345 + List<Integer> goal = new ArrayList<Integer>(); // i*TOKEN
19.346 + List<Integer> state = new ArrayList<Integer>(); // i*TOKEN
19.347 + List<Integer> drops = new ArrayList<Integer>(); // not tokens
19.348 + List<Integer> dups = new ArrayList<Integer>(); // not tokens
19.349 + final int TOKEN = 10; // to mark items which are symbolic only
19.350 + // state represents the argument values coming into target
19.351 + for (int i = 0; i < outargs; i++) {
19.352 + state.add(permutationOrNull[i] * TOKEN);
19.353 + }
19.354 + // goal represents the desired state
19.355 + for (int i = 0; i < inargs; i++) {
19.356 + if (state.contains(i * TOKEN)) {
19.357 + goal.add(i * TOKEN);
19.358 + } else {
19.359 + // adapter must initially drop all unused arguments
19.360 + drops.add(i);
19.361 + }
19.362 + }
19.363 + // detect duplications
19.364 + while (state.size() > goal.size()) {
19.365 + for (int i2 = 0; i2 < state.size(); i2++) {
19.366 + int arg1 = state.get(i2);
19.367 + int i1 = state.indexOf(arg1);
19.368 + if (i1 != i2) {
19.369 + // found duplicate occurrence at i2
19.370 + int arg2 = (inargs++) * TOKEN;
19.371 + state.set(i2, arg2);
19.372 + dups.add(goal.indexOf(arg1));
19.373 + goal.add(arg2);
19.374 + }
19.375 + }
19.376 + }
19.377 + assert(state.size() == goal.size());
19.378 + int size = goal.size();
19.379 + while (!state.equals(goal)) {
19.380 + // Look for a maximal sequence of adjacent misplaced arguments,
19.381 + // and try to rotate them into place.
19.382 + int bestRotArg = -10 * TOKEN, bestRotLen = 0;
19.383 + int thisRotArg = -10 * TOKEN, thisRotLen = 0;
19.384 + for (int i = 0; i < size; i++) {
19.385 + int arg = state.get(i);
19.386 + // Does this argument match the current run?
19.387 + if (arg == thisRotArg + TOKEN) {
19.388 + thisRotArg = arg;
19.389 + thisRotLen += 1;
19.390 + if (bestRotLen < thisRotLen) {
19.391 + bestRotLen = thisRotLen;
19.392 + bestRotArg = thisRotArg;
19.393 + }
19.394 + } else {
19.395 + // The old sequence (if any) stops here.
19.396 + thisRotLen = 0;
19.397 + thisRotArg = -10 * TOKEN;
19.398 + // But maybe a new one starts here also.
19.399 + int wantArg = goal.get(i);
19.400 + final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
19.401 + if (arg != wantArg &&
19.402 + arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
19.403 + arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
19.404 + thisRotArg = arg;
19.405 + thisRotLen = 1;
19.406 + }
19.407 + }
19.408 + }
19.409 + if (bestRotLen >= 2) {
19.410 + // Do a rotation if it can improve argument positioning
19.411 + // by at least 2 arguments. This is not always optimal,
19.412 + // but it seems to catch common cases.
19.413 + int dstEnd = state.indexOf(bestRotArg);
19.414 + int srcEnd = goal.indexOf(bestRotArg);
19.415 + int rotBy = dstEnd - srcEnd;
19.416 + int dstBeg = dstEnd - (bestRotLen - 1);
19.417 + int srcBeg = srcEnd - (bestRotLen - 1);
19.418 + assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
19.419 + // Make a span which covers both source and destination.
19.420 + int rotBeg = Math.min(dstBeg, srcBeg);
19.421 + int rotEnd = Math.max(dstEnd, srcEnd);
19.422 + int score = 0;
19.423 + for (int i = rotBeg; i <= rotEnd; i++) {
19.424 + if ((int)state.get(i) != (int)goal.get(i))
19.425 + score += 1;
19.426 + }
19.427 + List<Integer> rotSpan = state.subList(rotBeg, rotEnd+1);
19.428 + Collections.rotate(rotSpan, -rotBy); // reverse direction
19.429 + for (int i = rotBeg; i <= rotEnd; i++) {
19.430 + if ((int)state.get(i) != (int)goal.get(i))
19.431 + score -= 1;
19.432 + }
19.433 + if (score >= 2) {
19.434 + // Improved at least two argument positions. Do it.
19.435 + List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
19.436 + Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
19.437 + MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
19.438 + MethodHandle nextTarget
19.439 + = AdapterMethodHandle.makeRotateArguments(token, rotType, target,
19.440 + rotBeg, rotSpan.size(), rotBy);
19.441 + if (nextTarget != null) {
19.442 + //System.out.println("Rot: "+rotSpan+" by "+rotBy);
19.443 + target = nextTarget;
19.444 + oldType = rotType;
19.445 + continue;
19.446 + }
19.447 + }
19.448 + // Else de-rotate, and drop through to the swap-fest.
19.449 + Collections.rotate(rotSpan, rotBy);
19.450 + }
19.451 +
19.452 + // Now swap like the wind!
19.453 + List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
19.454 + for (int i = 0; i < size; i++) {
19.455 + // What argument do I want here?
19.456 + int arg = goal.get(i);
19.457 + if (arg != state.get(i)) {
19.458 + // Where is it now?
19.459 + int j = state.indexOf(arg);
19.460 + Collections.swap(ptypes, i, j);
19.461 + MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
19.462 + target = AdapterMethodHandle.makeSwapArguments(token, swapType, target, i, j);
19.463 + if (target == null) throw newIllegalArgumentException("cannot swap");
19.464 + assert(target.type() == swapType);
19.465 + oldType = swapType;
19.466 + Collections.swap(state, i, j);
19.467 + }
19.468 + }
19.469 + // One pass of swapping must finish the job.
19.470 + assert(state.equals(goal));
19.471 + }
19.472 + while (!dups.isEmpty()) {
19.473 + // Grab a contiguous trailing sequence of dups.
19.474 + int grab = dups.size() - 1;
19.475 + int dupArgPos = dups.get(grab), dupArgCount = 1;
19.476 + while (grab - 1 >= 0) {
19.477 + int dup0 = dups.get(grab - 1);
19.478 + if (dup0 != dupArgPos - 1) break;
19.479 + dupArgPos -= 1;
19.480 + dupArgCount += 1;
19.481 + grab -= 1;
19.482 + }
19.483 + //if (dupArgCount > 1) System.out.println("Dup: "+dups.subList(grab, dups.size()));
19.484 + dups.subList(grab, dups.size()).clear();
19.485 + // In the new target type drop that many args from the tail:
19.486 + List<Class<?>> ptypes = oldType.parameterList();
19.487 + ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
19.488 + MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
19.489 + target = AdapterMethodHandle.makeDupArguments(token, dupType, target, dupArgPos, dupArgCount);
19.490 + if (target == null)
19.491 + throw newIllegalArgumentException("cannot dup");
19.492 + oldType = target.type();
19.493 + }
19.494 + while (!drops.isEmpty()) {
19.495 + // Grab a contiguous initial sequence of drops.
19.496 + int dropArgPos = drops.get(0), dropArgCount = 1;
19.497 + while (dropArgCount < drops.size()) {
19.498 + int drop1 = drops.get(dropArgCount);
19.499 + if (drop1 != dropArgPos + dropArgCount) break;
19.500 + dropArgCount += 1;
19.501 + }
19.502 + //if (dropArgCount > 1) System.out.println("Drop: "+drops.subList(0, dropArgCount));
19.503 + drops.subList(0, dropArgCount).clear();
19.504 + List<Class<?>> dropTypes = newType.parameterList()
19.505 + .subList(dropArgPos, dropArgPos + dropArgCount);
19.506 + MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
19.507 + target = AdapterMethodHandle.makeDropArguments(token, dropType, target, dropArgPos, dropArgCount);
19.508 + if (target == null) throw newIllegalArgumentException("cannot drop");
19.509 + oldType = target.type();
19.510 + }
19.511 + }
19.512 + if (newType == oldType)
19.513 + return target;
19.514 + if (oldType.parameterCount() != newType.parameterCount())
19.515 + throw newIllegalArgumentException("mismatched parameter count");
19.516 MethodHandle res = AdapterMethodHandle.makePairwiseConvert(token, newType, target);
19.517 if (res != null)
19.518 return res;
19.519 @@ -241,7 +661,7 @@
19.520 // Use a heavier method: Convert all the arguments to Object,
19.521 // then back to the desired types. We might have to use Java-based
19.522 // method handles to do this.
19.523 - MethodType objType = MethodType.makeGeneric(argc);
19.524 + MethodType objType = MethodType.genericMethodType(argc);
19.525 MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(token, objType, target);
19.526 if (objTarget == null)
19.527 objTarget = FromGeneric.make(target);
19.528 @@ -272,83 +692,386 @@
19.529 Class<?>[] ptypes = oldType.parameterArray();
19.530 for (int i = 0; i < spreadCount; i++)
19.531 ptypes[spreadArg + i] = VerifyType.spreadArgElementType(spreadType, i);
19.532 - MethodType midType = MethodType.make(newType.returnType(), ptypes);
19.533 + MethodType midType = MethodType.methodType(newType.returnType(), ptypes);
19.534 // after spreading, some arguments may need further conversion
19.535 - target = convertArguments(token, target, midType, oldType, null);
19.536 - if (target == null)
19.537 + MethodHandle target2 = convertArguments(token, target, midType, oldType, null);
19.538 + if (target2 == null)
19.539 throw new UnsupportedOperationException("NYI: convert "+midType+" =calls=> "+oldType);
19.540 - res = AdapterMethodHandle.makeSpreadArguments(token, newType, target, spreadArgType, spreadArg, spreadCount);
19.541 + res = AdapterMethodHandle.makeSpreadArguments(token, newType, target2, spreadArgType, spreadArg, spreadCount);
19.542 + if (res != null)
19.543 + return res;
19.544 + res = SpreadGeneric.make(target2, spreadCount);
19.545 + if (res != null)
19.546 + res = convertArguments(token, res, newType, res.type(), null);
19.547 return res;
19.548 }
19.549
19.550 public static MethodHandle collectArguments(Access token,
19.551 MethodHandle target,
19.552 MethodType newType,
19.553 - int collectArg) {
19.554 - if (collectArg > 0)
19.555 - throw new UnsupportedOperationException("NYI");
19.556 - throw new UnsupportedOperationException("NYI");
19.557 + int collectArg,
19.558 + MethodHandle collector) {
19.559 + MethodType oldType = target.type(); // (a...,c)=>r
19.560 + if (collector == null) {
19.561 + int numCollect = newType.parameterCount() - oldType.parameterCount() + 1;
19.562 + collector = ValueConversions.varargsArray(numCollect);
19.563 + }
19.564 + // newType // (a..., b...)=>r
19.565 + MethodType colType = collector.type(); // (b...)=>c
19.566 + // oldType // (a..., b...)=>r
19.567 + assert(newType.parameterCount() == collectArg + colType.parameterCount());
19.568 + assert(oldType.parameterCount() == collectArg + 1);
19.569 + MethodHandle gtarget = convertArguments(token, target, oldType.generic(), oldType, null);
19.570 + MethodHandle gcollector = convertArguments(token, collector, colType.generic(), colType, null);
19.571 + if (gtarget == null || gcollector == null) return null;
19.572 + MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
19.573 + MethodHandle result = convertArguments(token, gresult, newType, gresult.type(), null);
19.574 + return result;
19.575 }
19.576 +
19.577 + public static MethodHandle filterArgument(Access token,
19.578 + MethodHandle target,
19.579 + int pos,
19.580 + MethodHandle filter) {
19.581 + Access.check(token);
19.582 + MethodType ttype = target.type(), gttype = ttype.generic();
19.583 + if (ttype != gttype) {
19.584 + target = convertArguments(token, target, gttype, ttype, null);
19.585 + ttype = gttype;
19.586 + }
19.587 + MethodType ftype = filter.type(), gftype = ftype.generic();
19.588 + if (ftype.parameterCount() != 1)
19.589 + throw new InternalError();
19.590 + if (ftype != gftype) {
19.591 + filter = convertArguments(token, filter, gftype, ftype, null);
19.592 + ftype = gftype;
19.593 + }
19.594 + if (ftype == ttype) {
19.595 + // simple unary case
19.596 + return FilterOneArgument.make(filter, target);
19.597 + }
19.598 + return FilterGeneric.makeArgumentFilter(pos, filter, target);
19.599 + }
19.600 +
19.601 + public static MethodHandle foldArguments(Access token,
19.602 + MethodHandle target,
19.603 + MethodType newType,
19.604 + MethodHandle combiner) {
19.605 + Access.check(token);
19.606 + MethodType oldType = target.type();
19.607 + MethodType ctype = combiner.type();
19.608 + MethodHandle gtarget = convertArguments(token, target, oldType.generic(), oldType, null);
19.609 + MethodHandle gcombiner = convertArguments(token, combiner, ctype.generic(), ctype, null);
19.610 + if (gtarget == null || gcombiner == null) return null;
19.611 + MethodHandle gresult = FilterGeneric.makeArgumentFolder(gcombiner, gtarget);
19.612 + MethodHandle result = convertArguments(token, gresult, newType, gresult.type(), null);
19.613 + return result;
19.614 + }
19.615 +
19.616 public static
19.617 MethodHandle dropArguments(Access token, MethodHandle target,
19.618 MethodType newType, int argnum) {
19.619 Access.check(token);
19.620 + int drops = newType.parameterCount() - target.type().parameterCount();
19.621 + MethodHandle res = AdapterMethodHandle.makeDropArguments(token, newType, target, argnum, drops);
19.622 + if (res != null)
19.623 + return res;
19.624 throw new UnsupportedOperationException("NYI");
19.625 }
19.626
19.627 + private static class GuardWithTest extends JavaMethodHandle {
19.628 + private final MethodHandle test, target, fallback;
19.629 + public GuardWithTest(MethodHandle test, MethodHandle target, MethodHandle fallback) {
19.630 + this(INVOKES[target.type().parameterCount()], test, target, fallback);
19.631 + }
19.632 + public GuardWithTest(MethodHandle invoker,
19.633 + MethodHandle test, MethodHandle target, MethodHandle fallback) {
19.634 + super(invoker);
19.635 + this.test = test;
19.636 + this.target = target;
19.637 + this.fallback = fallback;
19.638 + }
19.639 + @Override
19.640 + public String toString() {
19.641 + return target.toString();
19.642 + }
19.643 + private Object invoke_V(Object... av) throws Throwable {
19.644 + if (test.<boolean>invoke(av))
19.645 + return target.<Object>invoke(av);
19.646 + return fallback.<Object>invoke(av);
19.647 + }
19.648 + private Object invoke_L0() throws Throwable {
19.649 + if (test.<boolean>invoke())
19.650 + return target.<Object>invoke();
19.651 + return fallback.<Object>invoke();
19.652 + }
19.653 + private Object invoke_L1(Object a0) throws Throwable {
19.654 + if (test.<boolean>invoke(a0))
19.655 + return target.<Object>invoke(a0);
19.656 + return fallback.<Object>invoke(a0);
19.657 + }
19.658 + private Object invoke_L2(Object a0, Object a1) throws Throwable {
19.659 + if (test.<boolean>invoke(a0, a1))
19.660 + return target.<Object>invoke(a0, a1);
19.661 + return fallback.<Object>invoke(a0, a1);
19.662 + }
19.663 + private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
19.664 + if (test.<boolean>invoke(a0, a1, a2))
19.665 + return target.<Object>invoke(a0, a1, a2);
19.666 + return fallback.<Object>invoke(a0, a1, a2);
19.667 + }
19.668 + private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
19.669 + if (test.<boolean>invoke(a0, a1, a2, a3))
19.670 + return target.<Object>invoke(a0, a1, a2, a3);
19.671 + return fallback.<Object>invoke(a0, a1, a2, a3);
19.672 + }
19.673 + private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
19.674 + if (test.<boolean>invoke(a0, a1, a2, a3, a4))
19.675 + return target.<Object>invoke(a0, a1, a2, a3, a4);
19.676 + return fallback.<Object>invoke(a0, a1, a2, a3, a4);
19.677 + }
19.678 + private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
19.679 + if (test.<boolean>invoke(a0, a1, a2, a3, a4, a5))
19.680 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5);
19.681 + return fallback.<Object>invoke(a0, a1, a2, a3, a4, a5);
19.682 + }
19.683 + private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
19.684 + if (test.<boolean>invoke(a0, a1, a2, a3, a4, a5, a6))
19.685 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6);
19.686 + return fallback.<Object>invoke(a0, a1, a2, a3, a4, a5, a6);
19.687 + }
19.688 + private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
19.689 + if (test.<boolean>invoke(a0, a1, a2, a3, a4, a5, a6, a7))
19.690 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7);
19.691 + return fallback.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7);
19.692 + }
19.693 + static MethodHandle[] makeInvokes() {
19.694 + ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
19.695 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
19.696 + for (;;) {
19.697 + int nargs = invokes.size();
19.698 + String name = "invoke_L"+nargs;
19.699 + MethodHandle invoke = null;
19.700 + try {
19.701 + invoke = lookup.findVirtual(GuardWithTest.class, name, MethodType.genericMethodType(nargs));
19.702 + } catch (NoAccessException ex) {
19.703 + }
19.704 + if (invoke == null) break;
19.705 + invokes.add(invoke);
19.706 + }
19.707 + assert(invokes.size() == 9); // current number of methods
19.708 + return invokes.toArray(new MethodHandle[0]);
19.709 + };
19.710 + static final MethodHandle[] INVOKES = makeInvokes();
19.711 + // For testing use this:
19.712 + //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
19.713 + static final MethodHandle VARARGS_INVOKE;
19.714 + static {
19.715 + try {
19.716 + VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithTest.class, "invoke_V", MethodType.genericMethodType(0, true));
19.717 + } catch (NoAccessException ex) {
19.718 + throw new InternalError("");
19.719 + }
19.720 + }
19.721 + }
19.722 +
19.723 public static
19.724 MethodHandle makeGuardWithTest(Access token,
19.725 - final MethodHandle test,
19.726 - final MethodHandle target,
19.727 - final MethodHandle fallback) {
19.728 + MethodHandle test,
19.729 + MethodHandle target,
19.730 + MethodHandle fallback) {
19.731 Access.check(token);
19.732 - // %%% This is just a sketch. It needs to be de-boxed.
19.733 - // Adjust the handles to accept varargs lists.
19.734 MethodType type = target.type();
19.735 - Class<?> rtype = type.returnType();
19.736 - if (type.parameterCount() != 1 || type.parameterType(0).isPrimitive()) {
19.737 - MethodType vatestType = MethodType.make(boolean.class, Object[].class);
19.738 - MethodType vatargetType = MethodType.make(rtype, Object[].class);
19.739 - MethodHandle vaguard = makeGuardWithTest(token,
19.740 - MethodHandles.spreadArguments(test, vatestType),
19.741 - MethodHandles.spreadArguments(target, vatargetType),
19.742 - MethodHandles.spreadArguments(fallback, vatargetType));
19.743 - return MethodHandles.collectArguments(vaguard, type);
19.744 + int nargs = type.parameterCount();
19.745 + if (nargs < GuardWithTest.INVOKES.length) {
19.746 + MethodType gtype = type.generic();
19.747 + MethodHandle gtest = convertArguments(token, test, gtype.changeReturnType(boolean.class), test.type(), null);
19.748 + MethodHandle gtarget = convertArguments(token, target, gtype, type, null);
19.749 + MethodHandle gfallback = convertArguments(token, fallback, gtype, type, null);
19.750 + if (gtest == null || gtarget == null || gfallback == null) return null;
19.751 + MethodHandle gguard = new GuardWithTest(gtest, gtarget, gfallback);
19.752 + return convertArguments(token, gguard, type, gtype, null);
19.753 + } else {
19.754 + MethodType gtype = MethodType.genericMethodType(0, true);
19.755 + MethodHandle gtest = spreadArguments(token, test, gtype.changeReturnType(boolean.class), 0);
19.756 + MethodHandle gtarget = spreadArguments(token, target, gtype, 0);
19.757 + MethodHandle gfallback = spreadArguments(token, fallback, gtype, 0);
19.758 + MethodHandle gguard = new GuardWithTest(GuardWithTest.VARARGS_INVOKE, gtest, gtarget, gfallback);
19.759 + if (gtest == null || gtarget == null || gfallback == null) return null;
19.760 + return collectArguments(token, gguard, type, 0, null);
19.761 }
19.762 - if (rtype.isPrimitive()) {
19.763 - MethodType boxtype = type.changeReturnType(Object.class);
19.764 - MethodHandle boxguard = makeGuardWithTest(token,
19.765 - test,
19.766 - MethodHandles.convertArguments(target, boxtype),
19.767 - MethodHandles.convertArguments(fallback, boxtype));
19.768 - return MethodHandles.convertArguments(boxguard, type);
19.769 + }
19.770 +
19.771 + private static class GuardWithCatch extends JavaMethodHandle {
19.772 + private final MethodHandle target;
19.773 + private final Class<? extends Throwable> exType;
19.774 + private final MethodHandle catcher;
19.775 + public GuardWithCatch(MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
19.776 + this(INVOKES[target.type().parameterCount()], target, exType, catcher);
19.777 }
19.778 - // Got here? Reduced calling sequence to Object(Object).
19.779 - class Guarder {
19.780 - Object invoke(Object x) {
19.781 - // If javac supports MethodHandle.invoke directly:
19.782 - //z = vatest.invoke<boolean>(arguments);
19.783 - // If javac does not support direct MH.invoke calls:
19.784 - boolean z = (Boolean) MethodHandles.invoke_1(test, x);
19.785 - MethodHandle mh = (z ? target : fallback);
19.786 - return MethodHandles.invoke_1(mh, x);
19.787 - }
19.788 - MethodHandle handle() {
19.789 - MethodType invokeType = MethodType.makeGeneric(0, true);
19.790 - MethodHandle vh = IMPL_LOOKUP.bind(this, "invoke", invokeType);
19.791 - return MethodHandles.collectArguments(vh, target.type());
19.792 + public GuardWithCatch(MethodHandle invoker,
19.793 + MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
19.794 + super(invoker);
19.795 + this.target = target;
19.796 + this.exType = exType;
19.797 + this.catcher = catcher;
19.798 + }
19.799 + @Override
19.800 + public String toString() {
19.801 + return target.toString();
19.802 + }
19.803 + private Object invoke_V(Object... av) throws Throwable {
19.804 + try {
19.805 + return target.<Object>invoke(av);
19.806 + } catch (Throwable t) {
19.807 + if (!exType.isInstance(t)) throw t;
19.808 + return catcher.<Object>invoke(t, av);
19.809 }
19.810 }
19.811 - return new Guarder().handle();
19.812 + private Object invoke_L0() throws Throwable {
19.813 + try {
19.814 + return target.<Object>invoke();
19.815 + } catch (Throwable t) {
19.816 + if (!exType.isInstance(t)) throw t;
19.817 + return catcher.<Object>invoke(t);
19.818 + }
19.819 + }
19.820 + private Object invoke_L1(Object a0) throws Throwable {
19.821 + try {
19.822 + return target.<Object>invoke(a0);
19.823 + } catch (Throwable t) {
19.824 + if (!exType.isInstance(t)) throw t;
19.825 + return catcher.<Object>invoke(t, a0);
19.826 + }
19.827 + }
19.828 + private Object invoke_L2(Object a0, Object a1) throws Throwable {
19.829 + try {
19.830 + return target.<Object>invoke(a0, a1);
19.831 + } catch (Throwable t) {
19.832 + if (!exType.isInstance(t)) throw t;
19.833 + return catcher.<Object>invoke(t, a0, a1);
19.834 + }
19.835 + }
19.836 + private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
19.837 + try {
19.838 + return target.<Object>invoke(a0, a1, a2);
19.839 + } catch (Throwable t) {
19.840 + if (!exType.isInstance(t)) throw t;
19.841 + return catcher.<Object>invoke(t, a0, a1, a2);
19.842 + }
19.843 + }
19.844 + private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
19.845 + try {
19.846 + return target.<Object>invoke(a0, a1, a2, a3);
19.847 + } catch (Throwable t) {
19.848 + if (!exType.isInstance(t)) throw t;
19.849 + return catcher.<Object>invoke(t, a0, a1, a2, a3);
19.850 + }
19.851 + }
19.852 + private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
19.853 + try {
19.854 + return target.<Object>invoke(a0, a1, a2, a3, a4);
19.855 + } catch (Throwable t) {
19.856 + if (!exType.isInstance(t)) throw t;
19.857 + return catcher.<Object>invoke(t, a0, a1, a2, a3, a4);
19.858 + }
19.859 + }
19.860 + private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
19.861 + try {
19.862 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5);
19.863 + } catch (Throwable t) {
19.864 + if (!exType.isInstance(t)) throw t;
19.865 + return catcher.<Object>invoke(t, a0, a1, a2, a3, a4, a5);
19.866 + }
19.867 + }
19.868 + private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
19.869 + try {
19.870 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6);
19.871 + } catch (Throwable t) {
19.872 + if (!exType.isInstance(t)) throw t;
19.873 + return catcher.<Object>invoke(t, a0, a1, a2, a3, a4, a5, a6);
19.874 + }
19.875 + }
19.876 + private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
19.877 + try {
19.878 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7);
19.879 + } catch (Throwable t) {
19.880 + if (!exType.isInstance(t)) throw t;
19.881 + return catcher.<Object>invoke(t, a0, a1, a2, a3, a4, a5, a6, a7);
19.882 + }
19.883 + }
19.884 + static MethodHandle[] makeInvokes() {
19.885 + ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
19.886 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
19.887 + for (;;) {
19.888 + int nargs = invokes.size();
19.889 + String name = "invoke_L"+nargs;
19.890 + MethodHandle invoke = null;
19.891 + try {
19.892 + invoke = lookup.findVirtual(GuardWithCatch.class, name, MethodType.genericMethodType(nargs));
19.893 + } catch (NoAccessException ex) {
19.894 + }
19.895 + if (invoke == null) break;
19.896 + invokes.add(invoke);
19.897 + }
19.898 + assert(invokes.size() == 9); // current number of methods
19.899 + return invokes.toArray(new MethodHandle[0]);
19.900 + };
19.901 + static final MethodHandle[] INVOKES = makeInvokes();
19.902 + // For testing use this:
19.903 + //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);
19.904 + static final MethodHandle VARARGS_INVOKE;
19.905 + static {
19.906 + try {
19.907 + VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(GuardWithCatch.class, "invoke_V", MethodType.genericMethodType(0, true));
19.908 + } catch (NoAccessException ex) {
19.909 + throw new InternalError("");
19.910 + }
19.911 + }
19.912 + }
19.913 +
19.914 +
19.915 + public static
19.916 + MethodHandle makeGuardWithCatch(Access token,
19.917 + MethodHandle target,
19.918 + Class<? extends Throwable> exType,
19.919 + MethodHandle catcher) {
19.920 + Access.check(token);
19.921 + MethodType type = target.type();
19.922 + MethodType ctype = catcher.type();
19.923 + int nargs = type.parameterCount();
19.924 + if (nargs < GuardWithCatch.INVOKES.length) {
19.925 + MethodType gtype = type.generic();
19.926 + MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
19.927 + MethodHandle gtarget = convertArguments(token, target, gtype, type, null);
19.928 + MethodHandle gcatcher = convertArguments(token, catcher, gcatchType, ctype, null);
19.929 + MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher);
19.930 + if (gtarget == null || gcatcher == null || gguard == null) return null;
19.931 + return convertArguments(token, gguard, type, gtype, null);
19.932 + } else {
19.933 + MethodType gtype = MethodType.genericMethodType(0, true);
19.934 + MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
19.935 + MethodHandle gtarget = spreadArguments(token, target, gtype, 0);
19.936 + MethodHandle gcatcher = spreadArguments(token, catcher, gcatchType, 1);
19.937 + MethodHandle gguard = new GuardWithCatch(GuardWithCatch.VARARGS_INVOKE, gtarget, exType, gcatcher);
19.938 + if (gtarget == null || gcatcher == null || gguard == null) return null;
19.939 + return collectArguments(token, gguard, type, 0, null);
19.940 + }
19.941 }
19.942
19.943 public static
19.944 - MethodHandle combineArguments(Access token, MethodHandle target, MethodHandle checker, int pos) {
19.945 + MethodHandle throwException(Access token, MethodType type) {
19.946 Access.check(token);
19.947 - throw new UnsupportedOperationException("Not yet implemented");
19.948 + return AdapterMethodHandle.makeRetypeRaw(token, type, THROW_EXCEPTION);
19.949 }
19.950
19.951 - protected static String basicToString(MethodHandle target) {
19.952 + static final MethodHandle THROW_EXCEPTION
19.953 + = IMPL_LOOKUP.findStatic(MethodHandleImpl.class, "throwException",
19.954 + MethodType.methodType(Empty.class, Throwable.class));
19.955 + static <T extends Throwable> Empty throwException(T t) throws T { throw t; }
19.956 +
19.957 + public static String getNameString(Access token, MethodHandle target) {
19.958 + Access.check(token);
19.959 MemberName name = null;
19.960 if (target != null)
19.961 name = MethodHandleNatives.getMethodName(target);
19.962 @@ -357,17 +1080,30 @@
19.963 return name.getName();
19.964 }
19.965
19.966 - protected static String addTypeString(MethodHandle target, String name) {
19.967 - if (target == null) return name;
19.968 - return name+target.type();
19.969 - }
19.970 - static RuntimeException newIllegalArgumentException(String string) {
19.971 - return new IllegalArgumentException(string);
19.972 + public static String addTypeString(MethodHandle target) {
19.973 + if (target == null) return "null";
19.974 + return target.toString() + target.type();
19.975 }
19.976
19.977 - @Override
19.978 - public String toString() {
19.979 - MethodHandle self = (MethodHandle) this;
19.980 - return addTypeString(self, basicToString(self));
19.981 + public static void checkSpreadArgument(Object av, int n) {
19.982 + if (av == null ? n != 0 : ((Object[])av).length != n)
19.983 + throw newIllegalArgumentException("Array is not of length "+n);
19.984 + }
19.985 +
19.986 + public static void raiseException(int code, Object actual, Object required) {
19.987 + String message;
19.988 + // disregard the identity of the actual object, if it is not a class:
19.989 + if (!(actual instanceof Class) && !(actual instanceof MethodType))
19.990 + actual = actual.getClass();
19.991 + if (actual != null)
19.992 + message = "required "+required+" but encountered "+actual;
19.993 + else
19.994 + message = "required "+required;
19.995 + switch (code) {
19.996 + case 192: // checkcast
19.997 + throw new ClassCastException(message);
19.998 + default:
19.999 + throw new InternalError("unexpected code "+code+": "+message);
19.1000 + }
19.1001 }
19.1002 }
20.1 --- a/src/share/classes/sun/dyn/MethodHandleNatives.java Tue Jan 05 10:40:44 2010 +0800
20.2 +++ b/src/share/classes/sun/dyn/MethodHandleNatives.java Wed Jan 13 15:16:06 2010 -0800
20.3 @@ -25,6 +25,7 @@
20.4
20.5 package sun.dyn;
20.6
20.7 +import java.dyn.CallSite;
20.8 import java.dyn.MethodHandle;
20.9 import java.dyn.MethodType;
20.10 import java.lang.reflect.AccessibleObject;
20.11 @@ -60,7 +61,7 @@
20.12 static native void init(MethodType self);
20.13
20.14 /** Tell the JVM that we need to change the target of an invokedynamic. */
20.15 - static native void linkCallSite(CallSiteImpl site, MethodHandle target);
20.16 + static native void linkCallSite(CallSite site, MethodHandle target);
20.17
20.18 /** Fetch the vmtarget field.
20.19 * It will be sanitized as necessary to avoid exposing non-Java references.
20.20 @@ -84,8 +85,7 @@
20.21 }
20.22
20.23 /** Fetch the target of this method handle.
20.24 - * If it directly targets a method, return a tuple of method info.
20.25 - * The info is of the form new Object[]{defclass, name, sig, refclass}.
20.26 + * If it directly targets a method, return a MemberName for the method.
20.27 * If it is chained to another method handle, return that handle.
20.28 */
20.29 static Object getTargetInfo(MethodHandle self) {
20.30 @@ -123,7 +123,7 @@
20.31 registerNatives();
20.32 JVM_SUPPORT_ = true;
20.33 JVM_PUSH_LIMIT_ = getConstant(Constants.GC_JVM_PUSH_LIMIT);
20.34 - JVM_STACK_MOVE_UNIT_ = getConstant(Constants.GC_JVM_STACK_MOVE_LIMIT);
20.35 + JVM_STACK_MOVE_UNIT_ = getConstant(Constants.GC_JVM_STACK_MOVE_UNIT);
20.36 //sun.reflect.Reflection.registerMethodsToFilter(MethodHandleImpl.class, "init");
20.37 } catch (UnsatisfiedLinkError ee) {
20.38 // ignore; if we use init() methods later we'll see linkage errors
20.39 @@ -149,7 +149,7 @@
20.40 // MethodHandleImpl
20.41 static final int // for getConstant
20.42 GC_JVM_PUSH_LIMIT = 0,
20.43 - GC_JVM_STACK_MOVE_LIMIT = 1;
20.44 + GC_JVM_STACK_MOVE_UNIT = 1;
20.45 static final int
20.46 ETF_HANDLE_OR_METHOD_NAME = 0, // all available data (immediate MH or method)
20.47 ETF_DIRECT_HANDLE = 1, // ultimate method handle (will be a DMH, may be self)
20.48 @@ -178,19 +178,20 @@
20.49 */
20.50 static final int
20.51 OP_RETYPE_ONLY = 0x0, // no argument changes; straight retype
20.52 - OP_CHECK_CAST = 0x1, // ref-to-ref conversion; requires a Class argument
20.53 - OP_PRIM_TO_PRIM = 0x2, // converts from one primitive to another
20.54 - OP_REF_TO_PRIM = 0x3, // unboxes a wrapper to produce a primitive
20.55 - OP_PRIM_TO_REF = 0x4, // boxes a primitive into a wrapper (NYI)
20.56 - OP_SWAP_ARGS = 0x5, // swap arguments (vminfo is 2nd arg)
20.57 - OP_ROT_ARGS = 0x6, // rotate arguments (vminfo is displaced arg)
20.58 - OP_DUP_ARGS = 0x7, // duplicates one or more arguments (at TOS)
20.59 - OP_DROP_ARGS = 0x8, // remove one or more argument slots
20.60 - OP_COLLECT_ARGS = 0x9, // combine one or more arguments into a varargs (NYI)
20.61 - OP_SPREAD_ARGS = 0xA, // expand in place a varargs array (of known size)
20.62 - OP_FLYBY = 0xB, // operate first on reified argument list (NYI)
20.63 - OP_RICOCHET = 0xC, // run an adapter chain on the return value (NYI)
20.64 - CONV_OP_LIMIT = 0xD; // limit of CONV_OP enumeration
20.65 + OP_RETYPE_RAW = 0x1, // no argument changes; straight retype
20.66 + OP_CHECK_CAST = 0x2, // ref-to-ref conversion; requires a Class argument
20.67 + OP_PRIM_TO_PRIM = 0x3, // converts from one primitive to another
20.68 + OP_REF_TO_PRIM = 0x4, // unboxes a wrapper to produce a primitive
20.69 + OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper (NYI)
20.70 + OP_SWAP_ARGS = 0x6, // swap arguments (vminfo is 2nd arg)
20.71 + OP_ROT_ARGS = 0x7, // rotate arguments (vminfo is displaced arg)
20.72 + OP_DUP_ARGS = 0x8, // duplicates one or more arguments (at TOS)
20.73 + OP_DROP_ARGS = 0x9, // remove one or more argument slots
20.74 + OP_COLLECT_ARGS = 0xA, // combine one or more arguments into a varargs (NYI)
20.75 + OP_SPREAD_ARGS = 0xB, // expand in place a varargs array (of known size)
20.76 + OP_FLYBY = 0xC, // operate first on reified argument list (NYI)
20.77 + OP_RICOCHET = 0xD, // run an adapter chain on the return value (NYI)
20.78 + CONV_OP_LIMIT = 0xE; // limit of CONV_OP enumeration
20.79 /** Shift and mask values for decoding the AMH.conversion field.
20.80 * These numbers are shared with the JVM for creating AMHs.
20.81 */
20.82 @@ -209,6 +210,7 @@
20.83 // TODO: The following expression should be replaced by
20.84 // a JVM query.
20.85 ((1<<OP_RETYPE_ONLY)
20.86 + |(1<<OP_RETYPE_RAW)
20.87 |(1<<OP_CHECK_CAST)
20.88 |(1<<OP_PRIM_TO_PRIM)
20.89 |(1<<OP_REF_TO_PRIM)
20.90 @@ -216,6 +218,7 @@
20.91 |(1<<OP_ROT_ARGS)
20.92 |(1<<OP_DUP_ARGS)
20.93 |(1<<OP_DROP_ARGS)
20.94 + //|(1<<OP_SPREAD_ARGS) // FIXME: Check JVM assembly code.
20.95 );
20.96
20.97 /**
21.1 --- a/src/share/classes/sun/dyn/MethodTypeImpl.java Tue Jan 05 10:40:44 2010 +0800
21.2 +++ b/src/share/classes/sun/dyn/MethodTypeImpl.java Wed Jan 13 15:16:06 2010 -0800
21.3 @@ -27,6 +27,7 @@
21.4
21.5 import java.dyn.*;
21.6 import sun.dyn.util.Wrapper;
21.7 +import static sun.dyn.MemberName.newIllegalArgumentException;
21.8
21.9 /**
21.10 * Shared information for a group of method types, which differ
21.11 @@ -56,8 +57,8 @@
21.12 // Cached adapter information:
21.13 /*lazy*/ ToGeneric toGeneric; // convert cs. with prims to w/o
21.14 /*lazy*/ FromGeneric fromGeneric; // convert cs. w/o prims to with
21.15 + /*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
21.16 /*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
21.17 - ///*lazy*/ Invokers invokers; // cache of handy higher-order adapters
21.18
21.19 public MethodType erasedType() {
21.20 return erasedType;
21.21 @@ -68,7 +69,7 @@
21.22 }
21.23
21.24 /** Access methods for the internals of MethodType, supplied to
21.25 - * MethodTypeForm as a trusted agent.
21.26 + * MethodTypeImpl as a trusted agent.
21.27 */
21.28 static public interface MethodTypeFriend {
21.29 Class<?>[] ptypes(MethodType mt);
21.30 @@ -150,7 +151,7 @@
21.31 this.argToSlotTable = argToSlotTab;
21.32 this.slotToArgTable = slotToArgTab;
21.33
21.34 - if (pslotCount >= 256) throw new IllegalArgumentException("too many arguments");
21.35 + if (pslotCount >= 256) throw newIllegalArgumentException("too many arguments");
21.36
21.37 // send a few bits down to the JVM:
21.38 this.vmslots = parameterSlotCount();
21.39 @@ -378,10 +379,10 @@
21.40 static MethodTypeImpl findForm(MethodType mt) {
21.41 MethodType erased = canonicalize(mt, ERASE, ERASE);
21.42 if (erased == null) {
21.43 - // It is already erased. Make a new MethodTypeForm.
21.44 + // It is already erased. Make a new MethodTypeImpl.
21.45 return METHOD_TYPE_FRIEND.newMethodTypeForm(mt);
21.46 } else {
21.47 - // Share the MethodTypeForm with the erased version.
21.48 + // Share the MethodTypeImpl with the erased version.
21.49 return METHOD_TYPE_FRIEND.form(erased);
21.50 }
21.51 }
22.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
22.2 +++ b/src/share/classes/sun/dyn/SpreadGeneric.java Wed Jan 13 15:16:06 2010 -0800
22.3 @@ -0,0 +1,682 @@
22.4 +/*
22.5 + * Copyright 2008-2009 Sun Microsystems, Inc. All Rights Reserved.
22.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
22.7 + *
22.8 + * This code is free software; you can redistribute it and/or modify it
22.9 + * under the terms of the GNU General Public License version 2 only, as
22.10 + * published by the Free Software Foundation. Sun designates this
22.11 + * particular file as subject to the "Classpath" exception as provided
22.12 + * by Sun in the LICENSE file that accompanied this code.
22.13 + *
22.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
22.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
22.16 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22.17 + * version 2 for more details (a copy is included in the LICENSE file that
22.18 + * accompanied this code).
22.19 + *
22.20 + * You should have received a copy of the GNU General Public License version
22.21 + * 2 along with this work; if not, write to the Free Software Foundation,
22.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
22.23 + *
22.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
22.26 + * have any questions.
22.27 + */
22.28 +
22.29 +package sun.dyn;
22.30 +
22.31 +import java.dyn.JavaMethodHandle;
22.32 +import java.dyn.MethodHandle;
22.33 +import java.dyn.MethodHandles;
22.34 +import java.dyn.MethodType;
22.35 +import java.dyn.NoAccessException;
22.36 +import java.lang.reflect.Constructor;
22.37 +import java.lang.reflect.InvocationTargetException;
22.38 +import java.util.ArrayList;
22.39 +import sun.dyn.util.ValueConversions;
22.40 +import static sun.dyn.MemberName.newIllegalArgumentException;
22.41 +
22.42 +/**
22.43 + * Generic spread adapter.
22.44 + * Expands a final argument into multiple (zero or more) arguments, keeping the others the same.
22.45 + * @author jrose
22.46 + */
22.47 +class SpreadGeneric {
22.48 + // type for the outgoing call
22.49 + private final MethodType targetType;
22.50 + // number of arguments to spread
22.51 + private final int spreadCount;
22.52 + // prototype adapter (clone and customize for each new target!)
22.53 + private final Adapter adapter;
22.54 + // entry point for adapter (Adapter mh, a...) => ...
22.55 + private final MethodHandle entryPoint;
22.56 +
22.57 + /** Compute and cache information common to all spreading adapters
22.58 + * that accept calls of the given (generic) type.
22.59 + */
22.60 + private SpreadGeneric(MethodType targetType, int spreadCount) {
22.61 + assert(targetType == targetType.generic());
22.62 + this.targetType = targetType;
22.63 + this.spreadCount = spreadCount;
22.64 + // the target invoker will generally need casts on reference arguments
22.65 + MethodHandle[] ep = { null };
22.66 + Adapter ad = findAdapter(this, ep);
22.67 + if (ad != null) {
22.68 + this.adapter = ad;
22.69 + this.entryPoint = ep[0];
22.70 + return;
22.71 + }
22.72 + this.adapter = buildAdapterFromBytecodes(targetType, spreadCount, ep);
22.73 + this.entryPoint = ep[0];
22.74 + }
22.75 +
22.76 + /** From targetType remove the last spreadCount arguments, and instead
22.77 + * append a simple Object argument.
22.78 + */
22.79 + static MethodType preSpreadType(MethodType targetType, int spreadCount) {
22.80 + @SuppressWarnings("unchecked")
22.81 + ArrayList<Class<?>> params = new ArrayList(targetType.parameterList());
22.82 + int outargs = params.size();
22.83 + params.subList(outargs - spreadCount, outargs).clear();
22.84 + params.add(Object.class);
22.85 + return MethodType.methodType(targetType.returnType(), params);
22.86 + }
22.87 +
22.88 + MethodHandle makeInstance(MethodHandle target) {
22.89 + MethodType type = target.type();
22.90 + if (type != targetType) {
22.91 + throw new UnsupportedOperationException("NYI type="+type);
22.92 + }
22.93 + return adapter.makeInstance(this, target);
22.94 + }
22.95 +
22.96 + /** Build an adapter of the given generic type, which invokes typedTarget
22.97 + * on the incoming arguments, after unboxing as necessary.
22.98 + * The return value is boxed if necessary.
22.99 + * @param genericType the required type of the result
22.100 + * @param typedTarget the target
22.101 + * @return an adapter method handle
22.102 + */
22.103 + public static MethodHandle make(MethodHandle target, int spreadCount) {
22.104 + MethodType type = target.type();
22.105 + MethodType gtype = type.generic();
22.106 + if (type == gtype) {
22.107 + return SpreadGeneric.of(type, spreadCount).makeInstance(target);
22.108 + } else {
22.109 + MethodHandle gtarget = FromGeneric.make(target);
22.110 + assert(gtarget.type() == gtype);
22.111 + MethodHandle gspread = SpreadGeneric.of(gtype, spreadCount).makeInstance(gtarget);
22.112 + return ToGeneric.make(preSpreadType(type, spreadCount), gspread);
22.113 + }
22.114 + }
22.115 +
22.116 + /** Return the adapter information for this type's erasure. */
22.117 + static SpreadGeneric of(MethodType targetType, int spreadCount) {
22.118 + if (targetType != targetType.generic())
22.119 + throw new UnsupportedOperationException("NYI type="+targetType);
22.120 + MethodTypeImpl form = MethodTypeImpl.of(targetType);
22.121 + int outcount = form.parameterCount();
22.122 + assert(spreadCount <= outcount);
22.123 + SpreadGeneric[] spreadGens = form.spreadGeneric;
22.124 + if (spreadGens == null)
22.125 + form.spreadGeneric = spreadGens = new SpreadGeneric[outcount+1];
22.126 + SpreadGeneric spreadGen = spreadGens[spreadCount];
22.127 + if (spreadGen == null)
22.128 + spreadGens[spreadCount] = spreadGen = new SpreadGeneric(form.erasedType(), spreadCount);
22.129 + return spreadGen;
22.130 + }
22.131 +
22.132 + public String toString() {
22.133 + return getClass().getSimpleName()+targetType+"["+spreadCount+"]";
22.134 + }
22.135 +
22.136 + // This mini-api is called from an Adapter to manage the spread.
22.137 + /** A check/coercion that happens once before any selections. */
22.138 + protected Object check(Object av, int n) {
22.139 + MethodHandleImpl.checkSpreadArgument(av, n);
22.140 + return av;
22.141 + }
22.142 +
22.143 + /** The selection operator for spreading; note that it takes Object not Object[]. */
22.144 + protected Object select(Object av, int n) {
22.145 + return ((Object[])av)[n];
22.146 + }
22.147 + /*
22.148 + protected int select_I(Object av, int n) {
22.149 + // maybe return ((int[])select)[n]
22.150 + throw new UnsupportedOperationException("subclass resp.");
22.151 + }
22.152 + protected int select_J(Object av, int n) {
22.153 + // maybe return ((long[])select)[n]
22.154 + throw new UnsupportedOperationException("subclass resp.");
22.155 + }
22.156 + // */
22.157 +
22.158 + /* Create an adapter that handles spreading calls for the given type. */
22.159 + static Adapter findAdapter(SpreadGeneric outer, MethodHandle[] ep) {
22.160 + MethodType targetType = outer.targetType;
22.161 + int spreadCount = outer.spreadCount;
22.162 + int outargs = targetType.parameterCount();
22.163 + int inargs = outargs - spreadCount;
22.164 + if (inargs < 0) return null;
22.165 + MethodType entryType = MethodType.genericMethodType(inargs + 1); // 1 for av
22.166 + String cname1 = "S" + outargs;
22.167 + String[] cnames = { cname1 };
22.168 + String iname = "invoke_S"+spreadCount;
22.169 + // e.g., D5I2, D5, L5I2, L5; invoke_D5
22.170 + for (String cname : cnames) {
22.171 + Class<? extends Adapter> acls = Adapter.findSubClass(cname);
22.172 + if (acls == null) continue;
22.173 + // see if it has the required invoke method
22.174 + MethodHandle entryPoint = null;
22.175 + try {
22.176 + entryPoint = MethodHandleImpl.IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
22.177 + } catch (NoAccessException ex) {
22.178 + }
22.179 + if (entryPoint == null) continue;
22.180 + Constructor<? extends Adapter> ctor = null;
22.181 + try {
22.182 + ctor = acls.getDeclaredConstructor(SpreadGeneric.class);
22.183 + } catch (NoSuchMethodException ex) {
22.184 + } catch (SecurityException ex) {
22.185 + }
22.186 + if (ctor == null) continue;
22.187 + try {
22.188 + // Produce an instance configured as a prototype.
22.189 + Adapter ad = ctor.newInstance(outer);
22.190 + ep[0] = entryPoint;
22.191 + return ad;
22.192 + } catch (IllegalArgumentException ex) {
22.193 + } catch (InvocationTargetException wex) {
22.194 + Throwable ex = wex.getTargetException();
22.195 + if (ex instanceof Error) throw (Error)ex;
22.196 + if (ex instanceof RuntimeException) throw (RuntimeException)ex;
22.197 + } catch (InstantiationException ex) {
22.198 + } catch (IllegalAccessException ex) {
22.199 + }
22.200 + }
22.201 + return null;
22.202 + }
22.203 +
22.204 + static Adapter buildAdapterFromBytecodes(MethodType targetType,
22.205 + int spreadCount, MethodHandle[] ep) {
22.206 + throw new UnsupportedOperationException("NYI");
22.207 + }
22.208 +
22.209 + /**
22.210 + * This adapter takes some untyped arguments, and returns an untyped result.
22.211 + * Internally, it applies the invoker to the target, which causes the
22.212 + * objects to be unboxed; the result is a raw type in L/I/J/F/D.
22.213 + * This result is passed to convert, which is responsible for
22.214 + * converting the raw result into a boxed object.
22.215 + * The invoker is kept separate from the target because it can be
22.216 + * generated once per type erasure family, and reused across adapters.
22.217 + */
22.218 + static abstract class Adapter extends JavaMethodHandle {
22.219 + /*
22.220 + * class X<<R,int M,int N>> extends Adapter {
22.221 + * (Object**N)=>R target;
22.222 + * static int S = N-M;
22.223 + * Object invoke(Object**M a, Object v) = target(a..., v[0]...v[S-1]);
22.224 + * }
22.225 + */
22.226 + protected final SpreadGeneric outer;
22.227 + protected final MethodHandle target; // (any**N) => R
22.228 +
22.229 + @Override
22.230 + public String toString() {
22.231 + return target.toString();
22.232 + }
22.233 +
22.234 + static final MethodHandle NO_ENTRY = ValueConversions.identity();
22.235 +
22.236 + protected boolean isPrototype() { return target == null; }
22.237 + protected Adapter(SpreadGeneric outer) {
22.238 + super(NO_ENTRY);
22.239 + this.outer = outer;
22.240 + this.target = null;
22.241 + assert(isPrototype());
22.242 + }
22.243 +
22.244 + protected Adapter(SpreadGeneric outer, MethodHandle target) {
22.245 + super(outer.entryPoint);
22.246 + this.outer = outer;
22.247 + this.target = target;
22.248 + }
22.249 +
22.250 + /** Make a copy of self, with new fields. */
22.251 + protected abstract Adapter makeInstance(SpreadGeneric outer, MethodHandle target);
22.252 + // { return new ThisType(outer, target); }
22.253 +
22.254 + protected Object check(Object av, int n) {
22.255 + return outer.check(av, n);
22.256 + }
22.257 + protected Object select(Object av, int n) {
22.258 + return outer.select(av, n);
22.259 + }
22.260 +
22.261 + static private final String CLASS_PREFIX; // "sun.dyn.SpreadGeneric$"
22.262 + static {
22.263 + String aname = Adapter.class.getName();
22.264 + String sname = Adapter.class.getSimpleName();
22.265 + if (!aname.endsWith(sname)) throw new InternalError();
22.266 + CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
22.267 + }
22.268 + /** Find a sibing class of Adapter. */
22.269 + static Class<? extends Adapter> findSubClass(String name) {
22.270 + String cname = Adapter.CLASS_PREFIX + name;
22.271 + try {
22.272 + return Class.forName(cname).asSubclass(Adapter.class);
22.273 + } catch (ClassNotFoundException ex) {
22.274 + return null;
22.275 + } catch (ClassCastException ex) {
22.276 + return null;
22.277 + }
22.278 + }
22.279 + }
22.280 +
22.281 + /* generated classes follow this pattern:
22.282 + static class xS2 extends Adapter {
22.283 + protected xS2(SpreadGeneric outer) { super(outer); } // to build prototype
22.284 + protected xS2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.285 + protected xS2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new xS2(outer, t); }
22.286 + protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av,0);
22.287 + return target.<Object>invoke(a0, a1)); }
22.288 + protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av,1);
22.289 + return target.<Object>invoke(a0,
22.290 + super.select(av,0)); }
22.291 + protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av,1);
22.292 + return target.<Object>invoke(
22.293 + super.select(av,0), super.select(av,1)); }
22.294 + }
22.295 + // */
22.296 +
22.297 +/*
22.298 +: 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~
22.299 +//{{{
22.300 +import java.util.*;
22.301 +class genclasses {
22.302 + static String[][] TEMPLATES = { {
22.303 + "@for@ N=0..10",
22.304 + " //@each-cat@",
22.305 + " static class @cat@ extends Adapter {",
22.306 + " protected @cat@(SpreadGeneric outer) { super(outer); } // to build prototype",
22.307 + " protected @cat@(SpreadGeneric outer, MethodHandle t) { super(outer, t); }",
22.308 + " protected @cat@ makeInstance(SpreadGeneric outer, MethodHandle t) { return new @cat@(outer, t); }",
22.309 + " protected Object invoke_S0(@Tvav,@Object av) throws Throwable { av = super.check(av, 0);",
22.310 + " return target.<Object>invoke(@av@); }",
22.311 + " //@each-S@",
22.312 + " protected Object invoke_S@S@(@Tvav,@Object av) throws Throwable { av = super.check(av, @S@);",
22.313 + " return target.<Object>invoke(@av,@@sv@); }",
22.314 + " //@end-S@",
22.315 + " }",
22.316 + } };
22.317 + static final String NEWLINE_INDENT = "\n ";
22.318 + enum VAR {
22.319 + cat, N, S, av, av_, Tvav_, sv;
22.320 + public final String pattern = "@"+toString().replace('_','.')+"@";
22.321 + public String binding = toString();
22.322 + static void makeBindings(boolean topLevel, int outargs, int spread) {
22.323 + int inargs = outargs - spread;
22.324 + VAR.cat.binding = "S"+outargs;
22.325 + VAR.N.binding = String.valueOf(outargs); // outgoing arg count
22.326 + VAR.S.binding = String.valueOf(spread); // spread count
22.327 + String[] av = new String[inargs];
22.328 + String[] Tvav = new String[inargs];
22.329 + for (int i = 0; i < inargs; i++) {
22.330 + av[i] = arg(i);
22.331 + Tvav[i] = param("Object", av[i]);
22.332 + }
22.333 + VAR.av.binding = comma(av);
22.334 + VAR.av_.binding = comma(av, ", ");
22.335 + VAR.Tvav_.binding = comma(Tvav, ", ");
22.336 + String[] sv = new String[spread];
22.337 + for (int i = 0; i < spread; i++) {
22.338 + String spc = "";
22.339 + if (i % 4 == 0) spc = NEWLINE_INDENT;
22.340 + sv[i] = spc+"super.select(av,"+i+")";
22.341 + }
22.342 + VAR.sv.binding = comma(sv);
22.343 + }
22.344 + static String arg(int i) { return "a"+i; }
22.345 + static String param(String t, String a) { return t+" "+a; }
22.346 + static String comma(String[] v) { return comma(v, ""); }
22.347 + static String comma(String[] v, String sep) {
22.348 + if (v.length == 0) return "";
22.349 + String res = v[0];
22.350 + for (int i = 1; i < v.length; i++) res += ", "+v[i];
22.351 + return res + sep;
22.352 + }
22.353 + static String transform(String string) {
22.354 + for (VAR var : values())
22.355 + string = string.replaceAll(var.pattern, var.binding);
22.356 + return string;
22.357 + }
22.358 + }
22.359 + static String[] stringsIn(String[] strings, int beg, int end) {
22.360 + return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
22.361 + }
22.362 + static String[] stringsBefore(String[] strings, int pos) {
22.363 + return stringsIn(strings, 0, pos);
22.364 + }
22.365 + static String[] stringsAfter(String[] strings, int pos) {
22.366 + return stringsIn(strings, pos, strings.length);
22.367 + }
22.368 + static int indexAfter(String[] strings, int pos, String tag) {
22.369 + return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
22.370 + }
22.371 + static int indexBefore(String[] strings, int pos, String tag) {
22.372 + for (int i = pos, end = strings.length; ; i++) {
22.373 + if (i == end || strings[i].endsWith(tag)) return i;
22.374 + }
22.375 + }
22.376 + static int MIN_ARITY, MAX_ARITY;
22.377 + public static void main(String... av) {
22.378 + for (String[] template : TEMPLATES) {
22.379 + int forLinesLimit = indexBefore(template, 0, "@each-cat@");
22.380 + String[] forLines = stringsBefore(template, forLinesLimit);
22.381 + template = stringsAfter(template, forLinesLimit);
22.382 + for (String forLine : forLines)
22.383 + expandTemplate(forLine, template);
22.384 + }
22.385 + }
22.386 + static void expandTemplate(String forLine, String[] template) {
22.387 + String[] params = forLine.split("[^0-9]+");
22.388 + if (params[0].length() == 0) params = stringsAfter(params, 1);
22.389 + System.out.println("//params="+Arrays.asList(params));
22.390 + int pcur = 0;
22.391 + MIN_ARITY = Integer.valueOf(params[pcur++]);
22.392 + MAX_ARITY = Integer.valueOf(params[pcur++]);
22.393 + if (pcur != params.length) throw new RuntimeException("bad extra param: "+forLine);
22.394 + for (int outargs = MIN_ARITY; outargs <= MAX_ARITY; outargs++) {
22.395 + expandTemplate(template, true, outargs, 0);
22.396 + }
22.397 + }
22.398 + static void expandTemplate(String[] template, boolean topLevel, int outargs, int spread) {
22.399 + VAR.makeBindings(topLevel, outargs, spread);
22.400 + for (int i = 0; i < template.length; i++) {
22.401 + String line = template[i];
22.402 + if (line.endsWith("@each-cat@")) {
22.403 + // ignore
22.404 + } else if (line.endsWith("@each-S@")) {
22.405 + int blockEnd = indexAfter(template, i, "@end-S@");
22.406 + String[] block = stringsIn(template, i+1, blockEnd-1);
22.407 + for (int spread1 = spread+1; spread1 <= outargs; spread1++)
22.408 + expandTemplate(block, false, outargs, spread1);
22.409 + VAR.makeBindings(topLevel, outargs, spread);
22.410 + i = blockEnd-1; continue;
22.411 + } else {
22.412 + System.out.println(VAR.transform(line));
22.413 + }
22.414 + }
22.415 + }
22.416 +}
22.417 +//}}} */
22.418 +//params=[0, 10]
22.419 + static class S0 extends Adapter {
22.420 + protected S0(SpreadGeneric outer) { super(outer); } // to build prototype
22.421 + protected S0(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.422 + protected S0 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S0(outer, t); }
22.423 + protected Object invoke_S0(Object av) throws Throwable { av = super.check(av, 0);
22.424 + return target.<Object>invoke(); }
22.425 + }
22.426 + static class S1 extends Adapter {
22.427 + protected S1(SpreadGeneric outer) { super(outer); } // to build prototype
22.428 + protected S1(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.429 + protected S1 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S1(outer, t); }
22.430 + protected Object invoke_S0(Object a0, Object av) throws Throwable { av = super.check(av, 0);
22.431 + return target.<Object>invoke(a0); }
22.432 + protected Object invoke_S1(Object av) throws Throwable { av = super.check(av, 1);
22.433 + return target.<Object>invoke(
22.434 + super.select(av,0)); }
22.435 + }
22.436 + static class S2 extends Adapter {
22.437 + protected S2(SpreadGeneric outer) { super(outer); } // to build prototype
22.438 + protected S2(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.439 + protected S2 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S2(outer, t); }
22.440 + protected Object invoke_S0(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 0);
22.441 + return target.<Object>invoke(a0, a1); }
22.442 + protected Object invoke_S1(Object a0, Object av) throws Throwable { av = super.check(av, 1);
22.443 + return target.<Object>invoke(a0,
22.444 + super.select(av,0)); }
22.445 + protected Object invoke_S2(Object av) throws Throwable { av = super.check(av, 2);
22.446 + return target.<Object>invoke(
22.447 + super.select(av,0), super.select(av,1)); }
22.448 + }
22.449 + static class S3 extends Adapter {
22.450 + protected S3(SpreadGeneric outer) { super(outer); } // to build prototype
22.451 + protected S3(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.452 + protected S3 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S3(outer, t); }
22.453 + protected Object invoke_S0(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 0);
22.454 + return target.<Object>invoke(a0, a1, a2); }
22.455 + protected Object invoke_S1(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 1);
22.456 + return target.<Object>invoke(a0, a1,
22.457 + super.select(av,0)); }
22.458 + protected Object invoke_S2(Object a0, Object av) throws Throwable { av = super.check(av, 2);
22.459 + return target.<Object>invoke(a0,
22.460 + super.select(av,0), super.select(av,1)); }
22.461 + protected Object invoke_S3(Object av) throws Throwable { av = super.check(av, 3);
22.462 + return target.<Object>invoke(
22.463 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.464 + }
22.465 + static class S4 extends Adapter {
22.466 + protected S4(SpreadGeneric outer) { super(outer); } // to build prototype
22.467 + protected S4(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.468 + protected S4 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S4(outer, t); }
22.469 + protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 0);
22.470 + return target.<Object>invoke(a0, a1, a2, a3); }
22.471 + protected Object invoke_S1(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 1);
22.472 + return target.<Object>invoke(a0, a1, a2,
22.473 + super.select(av,0)); }
22.474 + protected Object invoke_S2(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 2);
22.475 + return target.<Object>invoke(a0, a1,
22.476 + super.select(av,0), super.select(av,1)); }
22.477 + protected Object invoke_S3(Object a0, Object av) throws Throwable { av = super.check(av, 3);
22.478 + return target.<Object>invoke(a0,
22.479 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.480 + protected Object invoke_S4(Object av) throws Throwable { av = super.check(av, 4);
22.481 + return target.<Object>invoke(
22.482 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.483 + }
22.484 + static class S5 extends Adapter {
22.485 + protected S5(SpreadGeneric outer) { super(outer); } // to build prototype
22.486 + protected S5(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.487 + protected S5 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S5(outer, t); }
22.488 + protected Object invoke_S0(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 0);
22.489 + return target.<Object>invoke(a0, a1, a2, a3, a4); }
22.490 + protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 1);
22.491 + return target.<Object>invoke(a0, a1, a2, a3,
22.492 + super.select(av,0)); }
22.493 + protected Object invoke_S2(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 2);
22.494 + return target.<Object>invoke(a0, a1, a2,
22.495 + super.select(av,0), super.select(av,1)); }
22.496 + protected Object invoke_S3(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 3);
22.497 + return target.<Object>invoke(a0, a1,
22.498 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.499 + protected Object invoke_S4(Object a0, Object av) throws Throwable { av = super.check(av, 4);
22.500 + return target.<Object>invoke(a0,
22.501 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.502 + protected Object invoke_S5(Object av) throws Throwable { av = super.check(av, 5);
22.503 + return target.<Object>invoke(
22.504 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.505 + super.select(av,4)); }
22.506 + }
22.507 + static class S6 extends Adapter {
22.508 + protected S6(SpreadGeneric outer) { super(outer); } // to build prototype
22.509 + protected S6(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.510 + protected S6 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S6(outer, t); }
22.511 + 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);
22.512 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5); }
22.513 + protected Object invoke_S1(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 1);
22.514 + return target.<Object>invoke(a0, a1, a2, a3, a4,
22.515 + super.select(av,0)); }
22.516 + protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 2);
22.517 + return target.<Object>invoke(a0, a1, a2, a3,
22.518 + super.select(av,0), super.select(av,1)); }
22.519 + protected Object invoke_S3(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 3);
22.520 + return target.<Object>invoke(a0, a1, a2,
22.521 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.522 + protected Object invoke_S4(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 4);
22.523 + return target.<Object>invoke(a0, a1,
22.524 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.525 + protected Object invoke_S5(Object a0, Object av) throws Throwable { av = super.check(av, 5);
22.526 + return target.<Object>invoke(a0,
22.527 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.528 + super.select(av,4)); }
22.529 + protected Object invoke_S6(Object av) throws Throwable { av = super.check(av, 6);
22.530 + return target.<Object>invoke(
22.531 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.532 + super.select(av,4), super.select(av,5)); }
22.533 + }
22.534 + static class S7 extends Adapter {
22.535 + protected S7(SpreadGeneric outer) { super(outer); } // to build prototype
22.536 + protected S7(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.537 + protected S7 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S7(outer, t); }
22.538 + 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);
22.539 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6); }
22.540 + 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);
22.541 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5,
22.542 + super.select(av,0)); }
22.543 + protected Object invoke_S2(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 2);
22.544 + return target.<Object>invoke(a0, a1, a2, a3, a4,
22.545 + super.select(av,0), super.select(av,1)); }
22.546 + protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 3);
22.547 + return target.<Object>invoke(a0, a1, a2, a3,
22.548 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.549 + protected Object invoke_S4(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 4);
22.550 + return target.<Object>invoke(a0, a1, a2,
22.551 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.552 + protected Object invoke_S5(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 5);
22.553 + return target.<Object>invoke(a0, a1,
22.554 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.555 + super.select(av,4)); }
22.556 + protected Object invoke_S6(Object a0, Object av) throws Throwable { av = super.check(av, 6);
22.557 + return target.<Object>invoke(a0,
22.558 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.559 + super.select(av,4), super.select(av,5)); }
22.560 + protected Object invoke_S7(Object av) throws Throwable { av = super.check(av, 7);
22.561 + return target.<Object>invoke(
22.562 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.563 + super.select(av,4), super.select(av,5), super.select(av,6)); }
22.564 + }
22.565 + static class S8 extends Adapter {
22.566 + protected S8(SpreadGeneric outer) { super(outer); } // to build prototype
22.567 + protected S8(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.568 + protected S8 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S8(outer, t); }
22.569 + 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);
22.570 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7); }
22.571 + 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);
22.572 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6,
22.573 + super.select(av,0)); }
22.574 + 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);
22.575 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5,
22.576 + super.select(av,0), super.select(av,1)); }
22.577 + protected Object invoke_S3(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 3);
22.578 + return target.<Object>invoke(a0, a1, a2, a3, a4,
22.579 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.580 + protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 4);
22.581 + return target.<Object>invoke(a0, a1, a2, a3,
22.582 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.583 + protected Object invoke_S5(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 5);
22.584 + return target.<Object>invoke(a0, a1, a2,
22.585 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.586 + super.select(av,4)); }
22.587 + protected Object invoke_S6(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 6);
22.588 + return target.<Object>invoke(a0, a1,
22.589 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.590 + super.select(av,4), super.select(av,5)); }
22.591 + protected Object invoke_S7(Object a0, Object av) throws Throwable { av = super.check(av, 7);
22.592 + return target.<Object>invoke(a0,
22.593 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.594 + super.select(av,4), super.select(av,5), super.select(av,6)); }
22.595 + protected Object invoke_S8(Object av) throws Throwable { av = super.check(av, 8);
22.596 + return target.<Object>invoke(
22.597 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.598 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
22.599 + }
22.600 + static class S9 extends Adapter {
22.601 + protected S9(SpreadGeneric outer) { super(outer); } // to build prototype
22.602 + protected S9(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.603 + protected S9 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S9(outer, t); }
22.604 + 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);
22.605 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
22.606 + 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);
22.607 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7,
22.608 + super.select(av,0)); }
22.609 + 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);
22.610 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6,
22.611 + super.select(av,0), super.select(av,1)); }
22.612 + 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);
22.613 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5,
22.614 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.615 + protected Object invoke_S4(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 4);
22.616 + return target.<Object>invoke(a0, a1, a2, a3, a4,
22.617 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.618 + protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 5);
22.619 + return target.<Object>invoke(a0, a1, a2, a3,
22.620 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.621 + super.select(av,4)); }
22.622 + protected Object invoke_S6(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 6);
22.623 + return target.<Object>invoke(a0, a1, a2,
22.624 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.625 + super.select(av,4), super.select(av,5)); }
22.626 + protected Object invoke_S7(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 7);
22.627 + return target.<Object>invoke(a0, a1,
22.628 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.629 + super.select(av,4), super.select(av,5), super.select(av,6)); }
22.630 + protected Object invoke_S8(Object a0, Object av) throws Throwable { av = super.check(av, 8);
22.631 + return target.<Object>invoke(a0,
22.632 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.633 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
22.634 + protected Object invoke_S9(Object av) throws Throwable { av = super.check(av, 9);
22.635 + return target.<Object>invoke(
22.636 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.637 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
22.638 + super.select(av,8)); }
22.639 + }
22.640 + static class S10 extends Adapter {
22.641 + protected S10(SpreadGeneric outer) { super(outer); } // to build prototype
22.642 + protected S10(SpreadGeneric outer, MethodHandle t) { super(outer, t); }
22.643 + protected S10 makeInstance(SpreadGeneric outer, MethodHandle t) { return new S10(outer, t); }
22.644 + 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);
22.645 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
22.646 + 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);
22.647 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7, a8,
22.648 + super.select(av,0)); }
22.649 + 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);
22.650 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6, a7,
22.651 + super.select(av,0), super.select(av,1)); }
22.652 + 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);
22.653 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5, a6,
22.654 + super.select(av,0), super.select(av,1), super.select(av,2)); }
22.655 + 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);
22.656 + return target.<Object>invoke(a0, a1, a2, a3, a4, a5,
22.657 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3)); }
22.658 + protected Object invoke_S5(Object a0, Object a1, Object a2, Object a3, Object a4, Object av) throws Throwable { av = super.check(av, 5);
22.659 + return target.<Object>invoke(a0, a1, a2, a3, a4,
22.660 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.661 + super.select(av,4)); }
22.662 + protected Object invoke_S6(Object a0, Object a1, Object a2, Object a3, Object av) throws Throwable { av = super.check(av, 6);
22.663 + return target.<Object>invoke(a0, a1, a2, a3,
22.664 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.665 + super.select(av,4), super.select(av,5)); }
22.666 + protected Object invoke_S7(Object a0, Object a1, Object a2, Object av) throws Throwable { av = super.check(av, 7);
22.667 + return target.<Object>invoke(a0, a1, a2,
22.668 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.669 + super.select(av,4), super.select(av,5), super.select(av,6)); }
22.670 + protected Object invoke_S8(Object a0, Object a1, Object av) throws Throwable { av = super.check(av, 8);
22.671 + return target.<Object>invoke(a0, a1,
22.672 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.673 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7)); }
22.674 + protected Object invoke_S9(Object a0, Object av) throws Throwable { av = super.check(av, 9);
22.675 + return target.<Object>invoke(a0,
22.676 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.677 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
22.678 + super.select(av,8)); }
22.679 + protected Object invoke_S10(Object av) throws Throwable { av = super.check(av, 10);
22.680 + return target.<Object>invoke(
22.681 + super.select(av,0), super.select(av,1), super.select(av,2), super.select(av,3),
22.682 + super.select(av,4), super.select(av,5), super.select(av,6), super.select(av,7),
22.683 + super.select(av,8), super.select(av,9)); }
22.684 + }
22.685 +}
23.1 --- a/src/share/classes/sun/dyn/ToGeneric.java Tue Jan 05 10:40:44 2010 +0800
23.2 +++ b/src/share/classes/sun/dyn/ToGeneric.java Wed Jan 13 15:16:06 2010 -0800
23.3 @@ -34,6 +34,7 @@
23.4 import java.lang.reflect.InvocationTargetException;
23.5 import sun.dyn.util.ValueConversions;
23.6 import sun.dyn.util.Wrapper;
23.7 +import static sun.dyn.MemberName.newIllegalArgumentException;
23.8
23.9 /**
23.10 * Adapters which mediate between incoming calls which are not generic
23.11 @@ -68,7 +69,7 @@
23.12 // conversion which unboxes a primitive return value
23.13 private final MethodHandle returnConversion;
23.14
23.15 - /** Compute and cache information common to all collecting adapters
23.16 + /** Compute and cache information common to all generifying (boxing) adapters
23.17 * that implement members of the erasure-family of the given erased type.
23.18 */
23.19 private ToGeneric(MethodType entryType) {
23.20 @@ -111,30 +112,48 @@
23.21 // primitive arguments according to their "raw" types int/long
23.22 MethodType intsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsInts();
23.23 ad = findAdapter(rawEntryTypeInit = intsAtEnd);
23.24 - if (ad == null) {
23.25 + MethodHandle rawEntryPoint;
23.26 + if (ad != null) {
23.27 + rawEntryPoint = ad.prototypeEntryPoint();
23.28 + } else {
23.29 // Perhaps the adapter is available only for longs.
23.30 // If so, we can use it, but there will have to be a little
23.31 // more stack motion on each call.
23.32 MethodType longsAtEnd = MethodTypeImpl.of(primsAtEnd).primsAsLongs();
23.33 ad = findAdapter(rawEntryTypeInit = longsAtEnd);
23.34 - if (ad == null) {
23.35 + if (ad != null) {
23.36 + MethodType eptWithLongs = longsAtEnd.insertParameterTypes(0, ad.getClass());
23.37 + MethodType eptWithInts = intsAtEnd.insertParameterTypes(0, ad.getClass());
23.38 + rawEntryPoint = ad.prototypeEntryPoint();
23.39 + MethodType midType = eptWithLongs; // will change longs to ints
23.40 + for (int i = 0, nargs = midType.parameterCount(); i < nargs; i++) {
23.41 + if (midType.parameterType(i) != eptWithInts.parameterType(i)) {
23.42 + assert(midType.parameterType(i) == long.class);
23.43 + assert(eptWithInts.parameterType(i) == int.class);
23.44 + MethodType nextType = midType.changeParameterType(i, int.class);
23.45 + rawEntryPoint = MethodHandle.convertArguments(Access.TOKEN,
23.46 + rawEntryPoint, nextType, midType, null);
23.47 + midType = nextType;
23.48 + }
23.49 + }
23.50 + assert(midType == eptWithInts);
23.51 + } else {
23.52 // If there is no statically compiled adapter,
23.53 // build one by means of dynamic bytecode generation.
23.54 ad = buildAdapterFromBytecodes(rawEntryTypeInit = intsAtEnd);
23.55 + rawEntryPoint = ad.prototypeEntryPoint();
23.56 }
23.57 }
23.58 - MethodHandle rawEntryPoint = ad.prototypeEntryPoint();
23.59 - MethodType tepType = entryType.insertParameterType(0, ad.getClass());
23.60 + MethodType tepType = entryType.insertParameterTypes(0, ad.getClass());
23.61 this.entryPoint =
23.62 - AdapterMethodHandle.makeRawRetypeOnly(Access.TOKEN, tepType, rawEntryPoint);
23.63 + AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, rawEntryPoint);
23.64 if (this.entryPoint == null)
23.65 throw new UnsupportedOperationException("cannot retype to "+entryType
23.66 - +" from "+rawEntryPoint.type().dropParameterType(0));
23.67 + +" from "+rawEntryPoint.type().dropParameterTypes(0, 1));
23.68 this.returnConversion = computeReturnConversion(entryType, rawEntryTypeInit, false);
23.69 this.rawEntryType = rawEntryTypeInit;
23.70 this.adapter = ad;
23.71 - this.invoker = makeRawArgumentFilter(invoker0,
23.72 - rawEntryPoint.type().dropParameterType(0), entryType);
23.73 + this.invoker = makeRawArgumentFilter(invoker0, rawEntryTypeInit, entryType);
23.74 }
23.75
23.76 /** A generic argument list will be created by a call of type 'raw'.
23.77 @@ -157,8 +176,8 @@
23.78 if (filteredInvoker == null) throw new UnsupportedOperationException("NYI");
23.79 }
23.80 MethodHandle reboxer = ValueConversions.rebox(dst, false);
23.81 - FilterGeneric gen = new FilterGeneric(filteredInvoker.type(), (short)(1+i), (short)1, 'R');
23.82 - filteredInvoker = gen.makeInstance(reboxer, filteredInvoker);
23.83 + filteredInvoker = FilterGeneric.makeArgumentFilter(1+i, reboxer, filteredInvoker);
23.84 + if (filteredInvoker == null) throw new InternalError();
23.85 }
23.86 if (filteredInvoker == null) return invoker;
23.87 return AdapterMethodHandle.makeRetypeOnly(Access.TOKEN, invoker.type(), filteredInvoker);
23.88 @@ -209,9 +228,9 @@
23.89 if (convert == null)
23.90 convert = computeReturnConversion(type, rawEntryType, true);
23.91 // retype erased reference arguments (the cast makes it safe to do this)
23.92 - MethodType tepType = type.insertParameterType(0, adapter.getClass());
23.93 + MethodType tepType = type.insertParameterTypes(0, adapter.getClass());
23.94 MethodHandle typedEntryPoint =
23.95 - AdapterMethodHandle.makeRawRetypeOnly(Access.TOKEN, tepType, entryPoint);
23.96 + AdapterMethodHandle.makeRetypeRaw(Access.TOKEN, tepType, entryPoint);
23.97 return adapter.makeInstance(typedEntryPoint, invoker, convert, genericTarget);
23.98 }
23.99
23.100 @@ -225,7 +244,7 @@
23.101 public static MethodHandle make(MethodType type, MethodHandle genericTarget) {
23.102 MethodType gtype = genericTarget.type();
23.103 if (type.generic() != gtype)
23.104 - throw new IllegalArgumentException();
23.105 + throw newIllegalArgumentException("type must be generic");
23.106 if (type == gtype) return genericTarget;
23.107 return ToGeneric.of(type).makeInstance(type, genericTarget);
23.108 }
23.109 @@ -283,7 +302,10 @@
23.110 try {
23.111 return ctor.newInstance(entryPoint);
23.112 } catch (IllegalArgumentException ex) {
23.113 - } catch (InvocationTargetException ex) {
23.114 + } catch (InvocationTargetException wex) {
23.115 + Throwable ex = wex.getTargetException();
23.116 + if (ex instanceof Error) throw (Error)ex;
23.117 + if (ex instanceof RuntimeException) throw (RuntimeException)ex;
23.118 } catch (InstantiationException ex) {
23.119 } catch (IllegalAccessException ex) {
23.120 }
23.121 @@ -317,6 +339,11 @@
23.122 protected final MethodHandle target; // Object... -> Object
23.123 protected final MethodHandle convert; // Object -> R
23.124
23.125 + @Override
23.126 + public String toString() {
23.127 + return target.toString();
23.128 + }
23.129 +
23.130 protected boolean isPrototype() { return target == null; }
23.131 /* Prototype constructor. */
23.132 protected Adapter(MethodHandle entryPoint) {
23.133 @@ -344,33 +371,33 @@
23.134 // { return new ThisType(entryPoint, convert, target); }
23.135
23.136 // Code to run when the arguments (<= 4) have all been boxed.
23.137 - protected Object target() { return invoker.<Object>invoke(target); }
23.138 - protected Object target(Object a0) { return invoker.<Object>invoke(target, a0); }
23.139 + protected Object target() throws Throwable { return invoker.<Object>invoke(target); }
23.140 + protected Object target(Object a0) throws Throwable { return invoker.<Object>invoke(target, a0); }
23.141 protected Object target(Object a0, Object a1)
23.142 - { return invoker.<Object>invoke(target, a0, a1); }
23.143 + throws Throwable { return invoker.<Object>invoke(target, a0, a1); }
23.144 protected Object target(Object a0, Object a1, Object a2)
23.145 - { return invoker.<Object>invoke(target, a0, a1, a2); }
23.146 + throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2); }
23.147 protected Object target(Object a0, Object a1, Object a2, Object a3)
23.148 - { return invoker.<Object>invoke(target, a0, a1, a2, a3); }
23.149 + throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3); }
23.150 /*
23.151 - protected Object target_0(Object... av) { return invoker.<Object>invoke(target, av); }
23.152 + protected Object target_0(Object... av) throws Throwable { return invoker.<Object>invoke(target, av); }
23.153 protected Object target_1(Object a0, Object... av)
23.154 - { return invoker.<Object>invoke(target, a0, (Object)av); }
23.155 + throws Throwable { return invoker.<Object>invoke(target, a0, (Object)av); }
23.156 protected Object target_2(Object a0, Object a1, Object... av)
23.157 - { return invoker.<Object>invoke(target, a0, a1, (Object)av); }
23.158 + throws Throwable { return invoker.<Object>invoke(target, a0, a1, (Object)av); }
23.159 protected Object target_3(Object a0, Object a1, Object a2, Object... av)
23.160 - { return invoker.<Object>invoke(target, a0, a1, a2, (Object)av); }
23.161 + throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, (Object)av); }
23.162 protected Object target_4(Object a0, Object a1, Object a2, Object a3, Object... av)
23.163 - { return invoker.<Object>invoke(target, a0, a1, a2, a3, (Object)av); }
23.164 + throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3, (Object)av); }
23.165 // */
23.166 // (For more than 4 arguments, generate the code in the adapter itself.)
23.167
23.168 // Code to run when the generic target has finished and produced a value.
23.169 - protected Object return_L(Object res) { return convert.<Object>invoke(res); }
23.170 - protected int return_I(Object res) { return convert.<int >invoke(res); }
23.171 - protected long return_J(Object res) { return convert.<long >invoke(res); }
23.172 - protected float return_F(Object res) { return convert.<float >invoke(res); }
23.173 - protected double return_D(Object res) { return convert.<double>invoke(res); }
23.174 + protected Object return_L(Object res) throws Throwable { return convert.<Object>invoke(res); }
23.175 + protected int return_I(Object res) throws Throwable { return convert.<int >invoke(res); }
23.176 + protected long return_J(Object res) throws Throwable { return convert.<long >invoke(res); }
23.177 + protected float return_F(Object res) throws Throwable { return convert.<float >invoke(res); }
23.178 + protected double return_D(Object res) throws Throwable { return convert.<double>invoke(res); }
23.179
23.180 static private final String CLASS_PREFIX; // "sun.dyn.ToGeneric$"
23.181 static {
23.182 @@ -397,25 +424,25 @@
23.183 protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.184 protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.185 protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
23.186 - protected Object target(Object a0) { return invoker.<Object>invoke(target, a0); }
23.187 - protected Object targetA1(Object a0) { return target(a0); }
23.188 - protected Object targetA1(int a0) { return target(a0); }
23.189 - protected Object targetA1(long a0) { return target(a0); }
23.190 - protected Object invoke_L(Object a0) { return return_L(targetA1(a0)); }
23.191 - protected int invoke_I(Object a0) { return return_I(targetA1(a0)); }
23.192 - protected long invoke_J(Object a0) { return return_J(targetA1(a0)); }
23.193 - protected float invoke_F(Object a0) { return return_F(targetA1(a0)); }
23.194 - protected double invoke_D(Object a0) { return return_D(targetA1(a0)); }
23.195 - protected Object invoke_L(int a0) { return return_L(targetA1(a0)); }
23.196 - protected int invoke_I(int a0) { return return_I(targetA1(a0)); }
23.197 - protected long invoke_J(int a0) { return return_J(targetA1(a0)); }
23.198 - protected float invoke_F(int a0) { return return_F(targetA1(a0)); }
23.199 - protected double invoke_D(int a0) { return return_D(targetA1(a0)); }
23.200 - protected Object invoke_L(long a0) { return return_L(targetA1(a0)); }
23.201 - protected int invoke_I(long a0) { return return_I(targetA1(a0)); }
23.202 - protected long invoke_J(long a0) { return return_J(targetA1(a0)); }
23.203 - protected float invoke_F(long a0) { return return_F(targetA1(a0)); }
23.204 - protected double invoke_D(long a0) { return return_D(targetA1(a0)); }
23.205 + protected Object target(Object a0) throws Throwable { return invoker.<Object>invoke(target, a0); }
23.206 + protected Object targetA1(Object a0) throws Throwable { return target(a0); }
23.207 + protected Object targetA1(int a0) throws Throwable { return target(a0); }
23.208 + protected Object targetA1(long a0) throws Throwable { return target(a0); }
23.209 + protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
23.210 + protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
23.211 + protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
23.212 + protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
23.213 + protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
23.214 + protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
23.215 + protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
23.216 + protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
23.217 + protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
23.218 + protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
23.219 + protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
23.220 + protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
23.221 + protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
23.222 + protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
23.223 + protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
23.224 }
23.225 // */
23.226
23.227 @@ -435,13 +462,13 @@
23.228 " protected @cat@(MethodHandle entryPoint) { super(entryPoint); } // to build prototype",
23.229 " protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }",
23.230 " protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new @cat@(e, i, c, t); }",
23.231 - " protected Object target(@Ovav@) { return invoker.<Object>invoke(target, @av@); }",
23.232 + " protected Object target(@Ovav@) throws Throwable { return invoker.<Object>invoke(target, @av@); }",
23.233 " //@each-Tv@",
23.234 - " protected Object target@cat@(@Tvav@) { return target(@av@); }",
23.235 + " protected Object target@cat@(@Tvav@) throws Throwable { return target(@av@); }",
23.236 " //@end-Tv@",
23.237 " //@each-Tv@",
23.238 " //@each-R@",
23.239 - " protected @R@ invoke_@Rc@(@Tvav@) { return return_@Rc@(target@cat@(@av@)); }",
23.240 + " protected @R@ invoke_@Rc@(@Tvav@) throws Throwable { return return_@Rc@(target@cat@(@av@)); }",
23.241 " //@end-R@",
23.242 " //@end-Tv@",
23.243 " }",
23.244 @@ -595,424 +622,424 @@
23.245 protected A0(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.246 protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.247 protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A0(e, i, c, t); }
23.248 - protected Object target() { return invoker.<Object>invoke(target); }
23.249 - protected Object targetA0() { return target(); }
23.250 - protected Object invoke_L() { return return_L(targetA0()); }
23.251 - protected int invoke_I() { return return_I(targetA0()); }
23.252 - protected long invoke_J() { return return_J(targetA0()); }
23.253 - protected float invoke_F() { return return_F(targetA0()); }
23.254 - protected double invoke_D() { return return_D(targetA0()); }
23.255 + protected Object target() throws Throwable { return invoker.<Object>invoke(target); }
23.256 + protected Object targetA0() throws Throwable { return target(); }
23.257 + protected Object invoke_L() throws Throwable { return return_L(targetA0()); }
23.258 + protected int invoke_I() throws Throwable { return return_I(targetA0()); }
23.259 + protected long invoke_J() throws Throwable { return return_J(targetA0()); }
23.260 + protected float invoke_F() throws Throwable { return return_F(targetA0()); }
23.261 + protected double invoke_D() throws Throwable { return return_D(targetA0()); }
23.262 }
23.263 static class A1 extends Adapter {
23.264 protected A1(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.265 protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.266 protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A1(e, i, c, t); }
23.267 - protected Object target(Object a0) { return invoker.<Object>invoke(target, a0); }
23.268 - protected Object targetA1(Object a0) { return target(a0); }
23.269 - protected Object targetA1(int a0) { return target(a0); }
23.270 - protected Object targetA1(long a0) { return target(a0); }
23.271 - protected Object invoke_L(Object a0) { return return_L(targetA1(a0)); }
23.272 - protected int invoke_I(Object a0) { return return_I(targetA1(a0)); }
23.273 - protected long invoke_J(Object a0) { return return_J(targetA1(a0)); }
23.274 - protected float invoke_F(Object a0) { return return_F(targetA1(a0)); }
23.275 - protected double invoke_D(Object a0) { return return_D(targetA1(a0)); }
23.276 - protected Object invoke_L(int a0) { return return_L(targetA1(a0)); }
23.277 - protected int invoke_I(int a0) { return return_I(targetA1(a0)); }
23.278 - protected long invoke_J(int a0) { return return_J(targetA1(a0)); }
23.279 - protected float invoke_F(int a0) { return return_F(targetA1(a0)); }
23.280 - protected double invoke_D(int a0) { return return_D(targetA1(a0)); }
23.281 - protected Object invoke_L(long a0) { return return_L(targetA1(a0)); }
23.282 - protected int invoke_I(long a0) { return return_I(targetA1(a0)); }
23.283 - protected long invoke_J(long a0) { return return_J(targetA1(a0)); }
23.284 - protected float invoke_F(long a0) { return return_F(targetA1(a0)); }
23.285 - protected double invoke_D(long a0) { return return_D(targetA1(a0)); }
23.286 + protected Object target(Object a0) throws Throwable { return invoker.<Object>invoke(target, a0); }
23.287 + protected Object targetA1(Object a0) throws Throwable { return target(a0); }
23.288 + protected Object targetA1(int a0) throws Throwable { return target(a0); }
23.289 + protected Object targetA1(long a0) throws Throwable { return target(a0); }
23.290 + protected Object invoke_L(Object a0) throws Throwable { return return_L(targetA1(a0)); }
23.291 + protected int invoke_I(Object a0) throws Throwable { return return_I(targetA1(a0)); }
23.292 + protected long invoke_J(Object a0) throws Throwable { return return_J(targetA1(a0)); }
23.293 + protected float invoke_F(Object a0) throws Throwable { return return_F(targetA1(a0)); }
23.294 + protected double invoke_D(Object a0) throws Throwable { return return_D(targetA1(a0)); }
23.295 + protected Object invoke_L(int a0) throws Throwable { return return_L(targetA1(a0)); }
23.296 + protected int invoke_I(int a0) throws Throwable { return return_I(targetA1(a0)); }
23.297 + protected long invoke_J(int a0) throws Throwable { return return_J(targetA1(a0)); }
23.298 + protected float invoke_F(int a0) throws Throwable { return return_F(targetA1(a0)); }
23.299 + protected double invoke_D(int a0) throws Throwable { return return_D(targetA1(a0)); }
23.300 + protected Object invoke_L(long a0) throws Throwable { return return_L(targetA1(a0)); }
23.301 + protected int invoke_I(long a0) throws Throwable { return return_I(targetA1(a0)); }
23.302 + protected long invoke_J(long a0) throws Throwable { return return_J(targetA1(a0)); }
23.303 + protected float invoke_F(long a0) throws Throwable { return return_F(targetA1(a0)); }
23.304 + protected double invoke_D(long a0) throws Throwable { return return_D(targetA1(a0)); }
23.305 }
23.306 static class A2 extends Adapter {
23.307 protected A2(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.308 protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.309 protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A2(e, i, c, t); }
23.310 - protected Object target(Object a0, Object a1) { return invoker.<Object>invoke(target, a0, a1); }
23.311 - protected Object targetA2(Object a0, Object a1) { return target(a0, a1); }
23.312 - protected Object targetA2(Object a0, int a1) { return target(a0, a1); }
23.313 - protected Object targetA2(int a0, int a1) { return target(a0, a1); }
23.314 - protected Object targetA2(Object a0, long a1) { return target(a0, a1); }
23.315 - protected Object targetA2(long a0, long a1) { return target(a0, a1); }
23.316 - protected Object invoke_L(Object a0, Object a1) { return return_L(targetA2(a0, a1)); }
23.317 - protected int invoke_I(Object a0, Object a1) { return return_I(targetA2(a0, a1)); }
23.318 - protected long invoke_J(Object a0, Object a1) { return return_J(targetA2(a0, a1)); }
23.319 - protected float invoke_F(Object a0, Object a1) { return return_F(targetA2(a0, a1)); }
23.320 - protected double invoke_D(Object a0, Object a1) { return return_D(targetA2(a0, a1)); }
23.321 - protected Object invoke_L(Object a0, int a1) { return return_L(targetA2(a0, a1)); }
23.322 - protected int invoke_I(Object a0, int a1) { return return_I(targetA2(a0, a1)); }
23.323 - protected long invoke_J(Object a0, int a1) { return return_J(targetA2(a0, a1)); }
23.324 - protected float invoke_F(Object a0, int a1) { return return_F(targetA2(a0, a1)); }
23.325 - protected double invoke_D(Object a0, int a1) { return return_D(targetA2(a0, a1)); }
23.326 - protected Object invoke_L(int a0, int a1) { return return_L(targetA2(a0, a1)); }
23.327 - protected int invoke_I(int a0, int a1) { return return_I(targetA2(a0, a1)); }
23.328 - protected long invoke_J(int a0, int a1) { return return_J(targetA2(a0, a1)); }
23.329 - protected float invoke_F(int a0, int a1) { return return_F(targetA2(a0, a1)); }
23.330 - protected double invoke_D(int a0, int a1) { return return_D(targetA2(a0, a1)); }
23.331 - protected Object invoke_L(Object a0, long a1) { return return_L(targetA2(a0, a1)); }
23.332 - protected int invoke_I(Object a0, long a1) { return return_I(targetA2(a0, a1)); }
23.333 - protected long invoke_J(Object a0, long a1) { return return_J(targetA2(a0, a1)); }
23.334 - protected float invoke_F(Object a0, long a1) { return return_F(targetA2(a0, a1)); }
23.335 - protected double invoke_D(Object a0, long a1) { return return_D(targetA2(a0, a1)); }
23.336 - protected Object invoke_L(long a0, long a1) { return return_L(targetA2(a0, a1)); }
23.337 - protected int invoke_I(long a0, long a1) { return return_I(targetA2(a0, a1)); }
23.338 - protected long invoke_J(long a0, long a1) { return return_J(targetA2(a0, a1)); }
23.339 - protected float invoke_F(long a0, long a1) { return return_F(targetA2(a0, a1)); }
23.340 - protected double invoke_D(long a0, long a1) { return return_D(targetA2(a0, a1)); }
23.341 + protected Object target(Object a0, Object a1) throws Throwable { return invoker.<Object>invoke(target, a0, a1); }
23.342 + protected Object targetA2(Object a0, Object a1) throws Throwable { return target(a0, a1); }
23.343 + protected Object targetA2(Object a0, int a1) throws Throwable { return target(a0, a1); }
23.344 + protected Object targetA2(int a0, int a1) throws Throwable { return target(a0, a1); }
23.345 + protected Object targetA2(Object a0, long a1) throws Throwable { return target(a0, a1); }
23.346 + protected Object targetA2(long a0, long a1) throws Throwable { return target(a0, a1); }
23.347 + protected Object invoke_L(Object a0, Object a1) throws Throwable { return return_L(targetA2(a0, a1)); }
23.348 + protected int invoke_I(Object a0, Object a1) throws Throwable { return return_I(targetA2(a0, a1)); }
23.349 + protected long invoke_J(Object a0, Object a1) throws Throwable { return return_J(targetA2(a0, a1)); }
23.350 + protected float invoke_F(Object a0, Object a1) throws Throwable { return return_F(targetA2(a0, a1)); }
23.351 + protected double invoke_D(Object a0, Object a1) throws Throwable { return return_D(targetA2(a0, a1)); }
23.352 + protected Object invoke_L(Object a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
23.353 + protected int invoke_I(Object a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
23.354 + protected long invoke_J(Object a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
23.355 + protected float invoke_F(Object a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
23.356 + protected double invoke_D(Object a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
23.357 + protected Object invoke_L(int a0, int a1) throws Throwable { return return_L(targetA2(a0, a1)); }
23.358 + protected int invoke_I(int a0, int a1) throws Throwable { return return_I(targetA2(a0, a1)); }
23.359 + protected long invoke_J(int a0, int a1) throws Throwable { return return_J(targetA2(a0, a1)); }
23.360 + protected float invoke_F(int a0, int a1) throws Throwable { return return_F(targetA2(a0, a1)); }
23.361 + protected double invoke_D(int a0, int a1) throws Throwable { return return_D(targetA2(a0, a1)); }
23.362 + protected Object invoke_L(Object a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
23.363 + protected int invoke_I(Object a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
23.364 + protected long invoke_J(Object a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
23.365 + protected float invoke_F(Object a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
23.366 + protected double invoke_D(Object a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
23.367 + protected Object invoke_L(long a0, long a1) throws Throwable { return return_L(targetA2(a0, a1)); }
23.368 + protected int invoke_I(long a0, long a1) throws Throwable { return return_I(targetA2(a0, a1)); }
23.369 + protected long invoke_J(long a0, long a1) throws Throwable { return return_J(targetA2(a0, a1)); }
23.370 + protected float invoke_F(long a0, long a1) throws Throwable { return return_F(targetA2(a0, a1)); }
23.371 + protected double invoke_D(long a0, long a1) throws Throwable { return return_D(targetA2(a0, a1)); }
23.372 }
23.373 static class A3 extends Adapter {
23.374 protected A3(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.375 protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.376 protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A3(e, i, c, t); }
23.377 - protected Object target(Object a0, Object a1, Object a2) { return invoker.<Object>invoke(target, a0, a1, a2); }
23.378 - protected Object targetA3(Object a0, Object a1, Object a2) { return target(a0, a1, a2); }
23.379 - protected Object targetA3(Object a0, Object a1, int a2) { return target(a0, a1, a2); }
23.380 - protected Object targetA3(Object a0, int a1, int a2) { return target(a0, a1, a2); }
23.381 - protected Object targetA3(int a0, int a1, int a2) { return target(a0, a1, a2); }
23.382 - protected Object targetA3(Object a0, Object a1, long a2) { return target(a0, a1, a2); }
23.383 - protected Object targetA3(Object a0, long a1, long a2) { return target(a0, a1, a2); }
23.384 - protected Object targetA3(long a0, long a1, long a2) { return target(a0, a1, a2); }
23.385 - protected Object invoke_L(Object a0, Object a1, Object a2) { return return_L(targetA3(a0, a1, a2)); }
23.386 - protected int invoke_I(Object a0, Object a1, Object a2) { return return_I(targetA3(a0, a1, a2)); }
23.387 - protected long invoke_J(Object a0, Object a1, Object a2) { return return_J(targetA3(a0, a1, a2)); }
23.388 - protected float invoke_F(Object a0, Object a1, Object a2) { return return_F(targetA3(a0, a1, a2)); }
23.389 - protected double invoke_D(Object a0, Object a1, Object a2) { return return_D(targetA3(a0, a1, a2)); }
23.390 - protected Object invoke_L(Object a0, Object a1, int a2) { return return_L(targetA3(a0, a1, a2)); }
23.391 - protected int invoke_I(Object a0, Object a1, int a2) { return return_I(targetA3(a0, a1, a2)); }
23.392 - protected long invoke_J(Object a0, Object a1, int a2) { return return_J(targetA3(a0, a1, a2)); }
23.393 - protected float invoke_F(Object a0, Object a1, int a2) { return return_F(targetA3(a0, a1, a2)); }
23.394 - protected double invoke_D(Object a0, Object a1, int a2) { return return_D(targetA3(a0, a1, a2)); }
23.395 - protected Object invoke_L(Object a0, int a1, int a2) { return return_L(targetA3(a0, a1, a2)); }
23.396 - protected int invoke_I(Object a0, int a1, int a2) { return return_I(targetA3(a0, a1, a2)); }
23.397 - protected long invoke_J(Object a0, int a1, int a2) { return return_J(targetA3(a0, a1, a2)); }
23.398 - protected float invoke_F(Object a0, int a1, int a2) { return return_F(targetA3(a0, a1, a2)); }
23.399 - protected double invoke_D(Object a0, int a1, int a2) { return return_D(targetA3(a0, a1, a2)); }
23.400 - protected Object invoke_L(int a0, int a1, int a2) { return return_L(targetA3(a0, a1, a2)); }
23.401 - protected int invoke_I(int a0, int a1, int a2) { return return_I(targetA3(a0, a1, a2)); }
23.402 - protected long invoke_J(int a0, int a1, int a2) { return return_J(targetA3(a0, a1, a2)); }
23.403 - protected float invoke_F(int a0, int a1, int a2) { return return_F(targetA3(a0, a1, a2)); }
23.404 - protected double invoke_D(int a0, int a1, int a2) { return return_D(targetA3(a0, a1, a2)); }
23.405 - protected Object invoke_L(Object a0, Object a1, long a2) { return return_L(targetA3(a0, a1, a2)); }
23.406 - protected int invoke_I(Object a0, Object a1, long a2) { return return_I(targetA3(a0, a1, a2)); }
23.407 - protected long invoke_J(Object a0, Object a1, long a2) { return return_J(targetA3(a0, a1, a2)); }
23.408 - protected float invoke_F(Object a0, Object a1, long a2) { return return_F(targetA3(a0, a1, a2)); }
23.409 - protected double invoke_D(Object a0, Object a1, long a2) { return return_D(targetA3(a0, a1, a2)); }
23.410 - protected Object invoke_L(Object a0, long a1, long a2) { return return_L(targetA3(a0, a1, a2)); }
23.411 - protected int invoke_I(Object a0, long a1, long a2) { return return_I(targetA3(a0, a1, a2)); }
23.412 - protected long invoke_J(Object a0, long a1, long a2) { return return_J(targetA3(a0, a1, a2)); }
23.413 - protected float invoke_F(Object a0, long a1, long a2) { return return_F(targetA3(a0, a1, a2)); }
23.414 - protected double invoke_D(Object a0, long a1, long a2) { return return_D(targetA3(a0, a1, a2)); }
23.415 - protected Object invoke_L(long a0, long a1, long a2) { return return_L(targetA3(a0, a1, a2)); }
23.416 - protected int invoke_I(long a0, long a1, long a2) { return return_I(targetA3(a0, a1, a2)); }
23.417 - protected long invoke_J(long a0, long a1, long a2) { return return_J(targetA3(a0, a1, a2)); }
23.418 - protected float invoke_F(long a0, long a1, long a2) { return return_F(targetA3(a0, a1, a2)); }
23.419 - protected double invoke_D(long a0, long a1, long a2) { return return_D(targetA3(a0, a1, a2)); }
23.420 + protected Object target(Object a0, Object a1, Object a2) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2); }
23.421 + protected Object targetA3(Object a0, Object a1, Object a2) throws Throwable { return target(a0, a1, a2); }
23.422 + protected Object targetA3(Object a0, Object a1, int a2) throws Throwable { return target(a0, a1, a2); }
23.423 + protected Object targetA3(Object a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
23.424 + protected Object targetA3(int a0, int a1, int a2) throws Throwable { return target(a0, a1, a2); }
23.425 + protected Object targetA3(Object a0, Object a1, long a2) throws Throwable { return target(a0, a1, a2); }
23.426 + protected Object targetA3(Object a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
23.427 + protected Object targetA3(long a0, long a1, long a2) throws Throwable { return target(a0, a1, a2); }
23.428 + protected Object invoke_L(Object a0, Object a1, Object a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.429 + protected int invoke_I(Object a0, Object a1, Object a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.430 + protected long invoke_J(Object a0, Object a1, Object a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.431 + protected float invoke_F(Object a0, Object a1, Object a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.432 + protected double invoke_D(Object a0, Object a1, Object a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.433 + protected Object invoke_L(Object a0, Object a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.434 + protected int invoke_I(Object a0, Object a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.435 + protected long invoke_J(Object a0, Object a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.436 + protected float invoke_F(Object a0, Object a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.437 + protected double invoke_D(Object a0, Object a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.438 + protected Object invoke_L(Object a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.439 + protected int invoke_I(Object a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.440 + protected long invoke_J(Object a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.441 + protected float invoke_F(Object a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.442 + protected double invoke_D(Object a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.443 + protected Object invoke_L(int a0, int a1, int a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.444 + protected int invoke_I(int a0, int a1, int a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.445 + protected long invoke_J(int a0, int a1, int a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.446 + protected float invoke_F(int a0, int a1, int a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.447 + protected double invoke_D(int a0, int a1, int a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.448 + protected Object invoke_L(Object a0, Object a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.449 + protected int invoke_I(Object a0, Object a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.450 + protected long invoke_J(Object a0, Object a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.451 + protected float invoke_F(Object a0, Object a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.452 + protected double invoke_D(Object a0, Object a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.453 + protected Object invoke_L(Object a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.454 + protected int invoke_I(Object a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.455 + protected long invoke_J(Object a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.456 + protected float invoke_F(Object a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.457 + protected double invoke_D(Object a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.458 + protected Object invoke_L(long a0, long a1, long a2) throws Throwable { return return_L(targetA3(a0, a1, a2)); }
23.459 + protected int invoke_I(long a0, long a1, long a2) throws Throwable { return return_I(targetA3(a0, a1, a2)); }
23.460 + protected long invoke_J(long a0, long a1, long a2) throws Throwable { return return_J(targetA3(a0, a1, a2)); }
23.461 + protected float invoke_F(long a0, long a1, long a2) throws Throwable { return return_F(targetA3(a0, a1, a2)); }
23.462 + protected double invoke_D(long a0, long a1, long a2) throws Throwable { return return_D(targetA3(a0, a1, a2)); }
23.463 }
23.464 //params=[4, 5, 2, 99, 99, 99]
23.465 static class A4 extends Adapter {
23.466 protected A4(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.467 protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.468 protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A4(e, i, c, t); }
23.469 - protected Object target(Object a0, Object a1, Object a2, Object a3) { return invoker.<Object>invoke(target, a0, a1, a2, a3); }
23.470 - protected Object targetA4(Object a0, Object a1, Object a2, Object a3) { return target(a0, a1, a2, a3); }
23.471 - protected Object targetA4(Object a0, Object a1, Object a2, int a3) { return target(a0, a1, a2, a3); }
23.472 - protected Object targetA4(Object a0, Object a1, int a2, int a3) { return target(a0, a1, a2, a3); }
23.473 - protected Object targetA4(Object a0, int a1, int a2, int a3) { return target(a0, a1, a2, a3); }
23.474 - protected Object targetA4(int a0, int a1, int a2, int a3) { return target(a0, a1, a2, a3); }
23.475 - protected Object targetA4(Object a0, Object a1, Object a2, long a3) { return target(a0, a1, a2, a3); }
23.476 - protected Object targetA4(Object a0, Object a1, long a2, long a3) { return target(a0, a1, a2, a3); }
23.477 - protected Object targetA4(Object a0, long a1, long a2, long a3) { return target(a0, a1, a2, a3); }
23.478 - protected Object targetA4(long a0, long a1, long a2, long a3) { return target(a0, a1, a2, a3); }
23.479 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.480 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.481 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.482 - protected Object invoke_L(Object a0, Object a1, Object a2, int a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.483 - protected int invoke_I(Object a0, Object a1, Object a2, int a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.484 - protected long invoke_J(Object a0, Object a1, Object a2, int a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.485 - protected Object invoke_L(Object a0, Object a1, int a2, int a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.486 - protected int invoke_I(Object a0, Object a1, int a2, int a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.487 - protected long invoke_J(Object a0, Object a1, int a2, int a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.488 - protected Object invoke_L(Object a0, int a1, int a2, int a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.489 - protected int invoke_I(Object a0, int a1, int a2, int a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.490 - protected long invoke_J(Object a0, int a1, int a2, int a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.491 - protected Object invoke_L(int a0, int a1, int a2, int a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.492 - protected int invoke_I(int a0, int a1, int a2, int a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.493 - protected long invoke_J(int a0, int a1, int a2, int a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.494 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.495 - protected int invoke_I(Object a0, Object a1, Object a2, long a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.496 - protected long invoke_J(Object a0, Object a1, Object a2, long a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.497 - protected Object invoke_L(Object a0, Object a1, long a2, long a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.498 - protected int invoke_I(Object a0, Object a1, long a2, long a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.499 - protected long invoke_J(Object a0, Object a1, long a2, long a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.500 - protected Object invoke_L(Object a0, long a1, long a2, long a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.501 - protected int invoke_I(Object a0, long a1, long a2, long a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.502 - protected long invoke_J(Object a0, long a1, long a2, long a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.503 - protected Object invoke_L(long a0, long a1, long a2, long a3) { return return_L(targetA4(a0, a1, a2, a3)); }
23.504 - protected int invoke_I(long a0, long a1, long a2, long a3) { return return_I(targetA4(a0, a1, a2, a3)); }
23.505 - protected long invoke_J(long a0, long a1, long a2, long a3) { return return_J(targetA4(a0, a1, a2, a3)); }
23.506 + protected Object target(Object a0, Object a1, Object a2, Object a3) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3); }
23.507 + protected Object targetA4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return target(a0, a1, a2, a3); }
23.508 + protected Object targetA4(Object a0, Object a1, Object a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
23.509 + protected Object targetA4(Object a0, Object a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
23.510 + protected Object targetA4(Object a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
23.511 + protected Object targetA4(int a0, int a1, int a2, int a3) throws Throwable { return target(a0, a1, a2, a3); }
23.512 + protected Object targetA4(Object a0, Object a1, Object a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
23.513 + protected Object targetA4(Object a0, Object a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
23.514 + protected Object targetA4(Object a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
23.515 + protected Object targetA4(long a0, long a1, long a2, long a3) throws Throwable { return target(a0, a1, a2, a3); }
23.516 + protected Object invoke_L(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.517 + protected int invoke_I(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.518 + protected long invoke_J(Object a0, Object a1, Object a2, Object a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.519 + protected Object invoke_L(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.520 + protected int invoke_I(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.521 + protected long invoke_J(Object a0, Object a1, Object a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.522 + protected Object invoke_L(Object a0, Object a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.523 + protected int invoke_I(Object a0, Object a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.524 + protected long invoke_J(Object a0, Object a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.525 + protected Object invoke_L(Object a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.526 + protected int invoke_I(Object a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.527 + protected long invoke_J(Object a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.528 + protected Object invoke_L(int a0, int a1, int a2, int a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.529 + protected int invoke_I(int a0, int a1, int a2, int a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.530 + protected long invoke_J(int a0, int a1, int a2, int a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.531 + protected Object invoke_L(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.532 + protected int invoke_I(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.533 + protected long invoke_J(Object a0, Object a1, Object a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.534 + protected Object invoke_L(Object a0, Object a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.535 + protected int invoke_I(Object a0, Object a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.536 + protected long invoke_J(Object a0, Object a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.537 + protected Object invoke_L(Object a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.538 + protected int invoke_I(Object a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.539 + protected long invoke_J(Object a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.540 + protected Object invoke_L(long a0, long a1, long a2, long a3) throws Throwable { return return_L(targetA4(a0, a1, a2, a3)); }
23.541 + protected int invoke_I(long a0, long a1, long a2, long a3) throws Throwable { return return_I(targetA4(a0, a1, a2, a3)); }
23.542 + protected long invoke_J(long a0, long a1, long a2, long a3) throws Throwable { return return_J(targetA4(a0, a1, a2, a3)); }
23.543 }
23.544 static class A5 extends Adapter {
23.545 protected A5(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.546 protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.547 protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A5(e, i, c, t); }
23.548 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4); }
23.549 - protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) { return target(a0, a1, a2, a3, a4); }
23.550 - protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int a4) { return target(a0, a1, a2, a3, a4); }
23.551 - protected Object targetA5(Object a0, Object a1, Object a2, int a3, int a4) { return target(a0, a1, a2, a3, a4); }
23.552 - protected Object targetA5(Object a0, Object a1, int a2, int a3, int a4) { return target(a0, a1, a2, a3, a4); }
23.553 - protected Object targetA5(Object a0, int a1, int a2, int a3, int a4) { return target(a0, a1, a2, a3, a4); }
23.554 - protected Object targetA5(int a0, int a1, int a2, int a3, int a4) { return target(a0, a1, a2, a3, a4); }
23.555 - protected Object targetA5(Object a0, Object a1, Object a2, Object a3, long a4) { return target(a0, a1, a2, a3, a4); }
23.556 - protected Object targetA5(Object a0, Object a1, Object a2, long a3, long a4) { return target(a0, a1, a2, a3, a4); }
23.557 - protected Object targetA5(Object a0, Object a1, long a2, long a3, long a4) { return target(a0, a1, a2, a3, a4); }
23.558 - protected Object targetA5(Object a0, long a1, long a2, long a3, long a4) { return target(a0, a1, a2, a3, a4); }
23.559 - protected Object targetA5(long a0, long a1, long a2, long a3, long a4) { return target(a0, a1, a2, a3, a4); }
23.560 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.561 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.562 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.563 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, int a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.564 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, int a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.565 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, int a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.566 - protected Object invoke_L(Object a0, Object a1, Object a2, int a3, int a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.567 - protected int invoke_I(Object a0, Object a1, Object a2, int a3, int a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.568 - protected long invoke_J(Object a0, Object a1, Object a2, int a3, int a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.569 - protected Object invoke_L(Object a0, Object a1, int a2, int a3, int a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.570 - protected int invoke_I(Object a0, Object a1, int a2, int a3, int a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.571 - protected long invoke_J(Object a0, Object a1, int a2, int a3, int a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.572 - protected Object invoke_L(Object a0, int a1, int a2, int a3, int a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.573 - protected int invoke_I(Object a0, int a1, int a2, int a3, int a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.574 - protected long invoke_J(Object a0, int a1, int a2, int a3, int a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.575 - protected Object invoke_L(int a0, int a1, int a2, int a3, int a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.576 - protected int invoke_I(int a0, int a1, int a2, int a3, int a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.577 - protected long invoke_J(int a0, int a1, int a2, int a3, int a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.578 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.579 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.580 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.581 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.582 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.583 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.584 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.585 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.586 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.587 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.588 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.589 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.590 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4) { return return_L(targetA5(a0, a1, a2, a3, a4)); }
23.591 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4) { return return_I(targetA5(a0, a1, a2, a3, a4)); }
23.592 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4) { return return_J(targetA5(a0, a1, a2, a3, a4)); }
23.593 + protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4); }
23.594 + protected Object targetA5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.595 + protected Object targetA5(Object a0, Object a1, Object a2, Object a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.596 + protected Object targetA5(Object a0, Object a1, Object a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.597 + protected Object targetA5(Object a0, Object a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.598 + protected Object targetA5(Object a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.599 + protected Object targetA5(int a0, int a1, int a2, int a3, int a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.600 + protected Object targetA5(Object a0, Object a1, Object a2, Object a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.601 + protected Object targetA5(Object a0, Object a1, Object a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.602 + protected Object targetA5(Object a0, Object a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.603 + protected Object targetA5(Object a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.604 + protected Object targetA5(long a0, long a1, long a2, long a3, long a4) throws Throwable { return target(a0, a1, a2, a3, a4); }
23.605 + 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)); }
23.606 + 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)); }
23.607 + 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)); }
23.608 + 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)); }
23.609 + 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)); }
23.610 + 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)); }
23.611 + 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)); }
23.612 + 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)); }
23.613 + 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)); }
23.614 + 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)); }
23.615 + 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)); }
23.616 + 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)); }
23.617 + 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)); }
23.618 + 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)); }
23.619 + 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)); }
23.620 + 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)); }
23.621 + 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)); }
23.622 + 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)); }
23.623 + 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)); }
23.624 + 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)); }
23.625 + 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)); }
23.626 + 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)); }
23.627 + 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)); }
23.628 + 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)); }
23.629 + 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)); }
23.630 + 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)); }
23.631 + 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)); }
23.632 + 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)); }
23.633 + 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)); }
23.634 + 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)); }
23.635 + 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)); }
23.636 + 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)); }
23.637 + 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)); }
23.638 }
23.639 //params=[6, 10, 2, 99, 0, 99]
23.640 static class A6 extends Adapter {
23.641 protected A6(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.642 protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.643 protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A6(e, i, c, t); }
23.644 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5); }
23.645 - protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return target(a0, a1, a2, a3, a4, a5); }
23.646 - protected Object targetA6(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.647 - protected Object targetA6(Object a0, Object a1, Object a2, Object a3, long a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.648 - protected Object targetA6(Object a0, Object a1, Object a2, long a3, long a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.649 - protected Object targetA6(Object a0, Object a1, long a2, long a3, long a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.650 - protected Object targetA6(Object a0, long a1, long a2, long a3, long a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.651 - protected Object targetA6(long a0, long a1, long a2, long a3, long a4, long a5) { return target(a0, a1, a2, a3, a4, a5); }
23.652 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.653 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.654 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.655 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.656 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.657 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.658 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.659 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.660 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.661 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.662 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.663 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.664 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.665 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.666 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.667 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.668 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.669 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.670 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5) { return return_L(targetA6(a0, a1, a2, a3, a4, a5)); }
23.671 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5) { return return_I(targetA6(a0, a1, a2, a3, a4, a5)); }
23.672 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5) { return return_J(targetA6(a0, a1, a2, a3, a4, a5)); }
23.673 + protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5); }
23.674 + 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); }
23.675 + 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); }
23.676 + 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); }
23.677 + 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); }
23.678 + 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); }
23.679 + 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); }
23.680 + 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); }
23.681 + 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)); }
23.682 + 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)); }
23.683 + 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)); }
23.684 + 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)); }
23.685 + 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)); }
23.686 + 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)); }
23.687 + 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)); }
23.688 + 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)); }
23.689 + 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)); }
23.690 + 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)); }
23.691 + 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)); }
23.692 + 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)); }
23.693 + 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)); }
23.694 + 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)); }
23.695 + 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)); }
23.696 + 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)); }
23.697 + 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)); }
23.698 + 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)); }
23.699 + 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)); }
23.700 + 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)); }
23.701 + 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)); }
23.702 }
23.703 static class A7 extends Adapter {
23.704 protected A7(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.705 protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.706 protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A7(e, i, c, t); }
23.707 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6); }
23.708 - protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.709 - protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.710 - protected Object targetA7(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.711 - protected Object targetA7(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.712 - protected Object targetA7(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.713 - protected Object targetA7(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.714 - protected Object targetA7(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.715 - protected Object targetA7(long a0, long a1, long a2, long a3, long a4, long a5, long a6) { return target(a0, a1, a2, a3, a4, a5, a6); }
23.716 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.717 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.718 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.719 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.720 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.721 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.722 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.723 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.724 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.725 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.726 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.727 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.728 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.729 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.730 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.731 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.732 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.733 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.734 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.735 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.736 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.737 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_L(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.738 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_I(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.739 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6) { return return_J(targetA7(a0, a1, a2, a3, a4, a5, a6)); }
23.740 + protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6); }
23.741 + 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); }
23.742 + 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); }
23.743 + 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); }
23.744 + 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); }
23.745 + 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); }
23.746 + 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); }
23.747 + 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); }
23.748 + 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); }
23.749 + 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)); }
23.750 + 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)); }
23.751 + 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)); }
23.752 + 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)); }
23.753 + 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)); }
23.754 + 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)); }
23.755 + 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)); }
23.756 + 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)); }
23.757 + 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)); }
23.758 + 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)); }
23.759 + 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)); }
23.760 + 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)); }
23.761 + 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)); }
23.762 + 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)); }
23.763 + 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)); }
23.764 + 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)); }
23.765 + 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)); }
23.766 + 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)); }
23.767 + 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)); }
23.768 + 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)); }
23.769 + 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)); }
23.770 + 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)); }
23.771 + 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)); }
23.772 + 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)); }
23.773 }
23.774 static class A8 extends Adapter {
23.775 protected A8(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.776 protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.777 protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A8(e, i, c, t); }
23.778 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7); }
23.779 - protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.780 - protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.781 - protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.782 - protected Object targetA8(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.783 - protected Object targetA8(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.784 - protected Object targetA8(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.785 - protected Object targetA8(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.786 - protected Object targetA8(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.787 - protected Object targetA8(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return target(a0, a1, a2, a3, a4, a5, a6, a7); }
23.788 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.789 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.790 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.791 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.792 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.793 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.794 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.795 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.796 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.797 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.798 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.799 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.800 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.801 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.802 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.803 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.804 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.805 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.806 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.807 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.808 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.809 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.810 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.811 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.812 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_L(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.813 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_I(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.814 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) { return return_J(targetA8(a0, a1, a2, a3, a4, a5, a6, a7)); }
23.815 + protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7); }
23.816 + 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); }
23.817 + 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); }
23.818 + 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); }
23.819 + 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); }
23.820 + 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); }
23.821 + 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); }
23.822 + 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); }
23.823 + 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); }
23.824 + 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); }
23.825 + 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)); }
23.826 + 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)); }
23.827 + 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)); }
23.828 + 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)); }
23.829 + 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)); }
23.830 + 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)); }
23.831 + 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)); }
23.832 + 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)); }
23.833 + 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)); }
23.834 + 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)); }
23.835 + 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)); }
23.836 + 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)); }
23.837 + 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)); }
23.838 + 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)); }
23.839 + 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)); }
23.840 + 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)); }
23.841 + 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)); }
23.842 + 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)); }
23.843 + 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)); }
23.844 + 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)); }
23.845 + 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)); }
23.846 + 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)); }
23.847 + 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)); }
23.848 + 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)); }
23.849 + 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)); }
23.850 + 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)); }
23.851 + 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)); }
23.852 }
23.853 static class A9 extends Adapter {
23.854 protected A9(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.855 protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.856 protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A9(e, i, c, t); }
23.857 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.858 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.859 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.860 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.861 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.862 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.863 - protected Object targetA9(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.864 - protected Object targetA9(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.865 - protected Object targetA9(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.866 - protected Object targetA9(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.867 - protected Object targetA9(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.868 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.869 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.870 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.871 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.872 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.873 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.874 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.875 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.876 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.877 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.878 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.879 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.880 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.881 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.882 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.883 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.884 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.885 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.886 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.887 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.888 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.889 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.890 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.891 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.892 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.893 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.894 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.895 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_L(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.896 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_I(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.897 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) { return return_J(targetA9(a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
23.898 + 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.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8); }
23.899 + 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); }
23.900 + 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); }
23.901 + 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); }
23.902 + 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); }
23.903 + 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); }
23.904 + 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); }
23.905 + 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); }
23.906 + 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); }
23.907 + 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); }
23.908 + 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); }
23.909 + 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)); }
23.910 + 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)); }
23.911 + 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)); }
23.912 + 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)); }
23.913 + 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)); }
23.914 + 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)); }
23.915 + 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)); }
23.916 + 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)); }
23.917 + 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)); }
23.918 + 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)); }
23.919 + 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)); }
23.920 + 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)); }
23.921 + 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)); }
23.922 + 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)); }
23.923 + 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)); }
23.924 + 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)); }
23.925 + 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)); }
23.926 + 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)); }
23.927 + 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)); }
23.928 + 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)); }
23.929 + 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)); }
23.930 + 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)); }
23.931 + 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)); }
23.932 + 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)); }
23.933 + 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)); }
23.934 + 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)); }
23.935 + 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)); }
23.936 + 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)); }
23.937 + 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)); }
23.938 + 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)); }
23.939 }
23.940 static class A10 extends Adapter {
23.941 protected A10(MethodHandle entryPoint) { super(entryPoint); } // to build prototype
23.942 protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { super(e, i, c, t); }
23.943 protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t) { return new A10(e, i, c, t); }
23.944 - protected Object target(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return invoker.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.945 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.946 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.947 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.948 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.949 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.950 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.951 - protected Object targetA10(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.952 - protected Object targetA10(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.953 - protected Object targetA10(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.954 - protected Object targetA10(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.955 - protected Object targetA10(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return target(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.956 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.957 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.958 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.959 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.960 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.961 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.962 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.963 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.964 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.965 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.966 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.967 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.968 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.969 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.970 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.971 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.972 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.973 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, Object a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.974 - protected Object invoke_L(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.975 - protected int invoke_I(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.976 - protected long invoke_J(Object a0, Object a1, Object a2, Object a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.977 - protected Object invoke_L(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.978 - protected int invoke_I(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.979 - protected long invoke_J(Object a0, Object a1, Object a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.980 - protected Object invoke_L(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.981 - protected int invoke_I(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.982 - protected long invoke_J(Object a0, Object a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.983 - protected Object invoke_L(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.984 - protected int invoke_I(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.985 - protected long invoke_J(Object a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.986 - protected Object invoke_L(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_L(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.987 - protected int invoke_I(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_I(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.988 - protected long invoke_J(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { return return_J(targetA10(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
23.989 + 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.<Object>invoke(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
23.990 + 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); }
23.991 + 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); }
23.992 + 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); }
23.993 + 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); }
23.994 + 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); }
23.995 + 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); }
23.996 + 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); }
23.997 + 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); }
23.998 + 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); }
23.999 + 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); }
23.1000 + 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); }
23.1001 + 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)); }
23.1002 + 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)); }
23.1003 + 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)); }
23.1004 + 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)); }
23.1005 + 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)); }
23.1006 + 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)); }
23.1007 + 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)); }
23.1008 + 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)); }
23.1009 + 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)); }
23.1010 + 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)); }
23.1011 + 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)); }
23.1012 + 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)); }
23.1013 + 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)); }
23.1014 + 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)); }
23.1015 + 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)); }
23.1016 + 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)); }
23.1017 + 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)); }
23.1018 + 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)); }
23.1019 + 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)); }
23.1020 + 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)); }
23.1021 + 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)); }
23.1022 + 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)); }
23.1023 + 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)); }
23.1024 + 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)); }
23.1025 + 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)); }
23.1026 + 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)); }
23.1027 + 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)); }
23.1028 + 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)); }
23.1029 + 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)); }
23.1030 + 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)); }
23.1031 + 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)); }
23.1032 + 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)); }
23.1033 + 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)); }
23.1034 }
23.1035 }
24.1 --- a/src/share/classes/sun/dyn/empty/Empty.java Tue Jan 05 10:40:44 2010 +0800
24.2 +++ b/src/share/classes/sun/dyn/empty/Empty.java Wed Jan 13 15:16:06 2010 -0800
24.3 @@ -29,6 +29,10 @@
24.4 * An empty class in an empty package.
24.5 * Used as a proxy for unprivileged code, since making access checks
24.6 * against it will only succeed against public methods in public types.
24.7 + * <p>
24.8 + * This class also stands (internally to sun.dyn) for the type of a
24.9 + * value that cannot be produced, because the expression of this type
24.10 + * always returns abnormally. (Cf. Nothing in the closures proposal.)
24.11 * @author jrose
24.12 */
24.13 public class Empty {
25.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
25.2 +++ b/src/share/classes/sun/dyn/util/BytecodeDescriptor.java Wed Jan 13 15:16:06 2010 -0800
25.3 @@ -0,0 +1,137 @@
25.4 +/*
25.5 + * Copyright 2008-2009 Sun Microsystems, Inc. All Rights Reserved.
25.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
25.7 + *
25.8 + * This code is free software; you can redistribute it and/or modify it
25.9 + * under the terms of the GNU General Public License version 2 only, as
25.10 + * published by the Free Software Foundation. Sun designates this
25.11 + * particular file as subject to the "Classpath" exception as provided
25.12 + * by Sun in the LICENSE file that accompanied this code.
25.13 + *
25.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
25.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
25.16 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25.17 + * version 2 for more details (a copy is included in the LICENSE file that
25.18 + * accompanied this code).
25.19 + *
25.20 + * You should have received a copy of the GNU General Public License version
25.21 + * 2 along with this work; if not, write to the Free Software Foundation,
25.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
25.23 + *
25.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
25.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
25.26 + * have any questions.
25.27 + */
25.28 +
25.29 +package sun.dyn.util;
25.30 +
25.31 +import java.dyn.MethodType;
25.32 +import java.util.ArrayList;
25.33 +import java.util.List;
25.34 +
25.35 +/**
25.36 + * Utility routines for dealing with bytecode-level signatures.
25.37 + * @author jrose
25.38 + */
25.39 +public class BytecodeDescriptor {
25.40 +
25.41 + private BytecodeDescriptor() { } // cannot instantiate
25.42 +
25.43 + public static List<Class<?>> parseMethod(String bytecodeSignature, ClassLoader loader) {
25.44 + return parseMethod(bytecodeSignature, 0, bytecodeSignature.length(), loader);
25.45 + }
25.46 +
25.47 + static List<Class<?>> parseMethod(String bytecodeSignature,
25.48 + int start, int end, ClassLoader loader) {
25.49 + if (loader == null)
25.50 + loader = ClassLoader.getSystemClassLoader();
25.51 + String str = bytecodeSignature;
25.52 + int[] i = {start};
25.53 + ArrayList<Class<?>> ptypes = new ArrayList<Class<?>>();
25.54 + if (i[0] < end && str.charAt(i[0]) == '(') {
25.55 + ++i[0]; // skip '('
25.56 + while (i[0] < end && str.charAt(i[0]) != ')') {
25.57 + Class<?> pt = parseSig(str, i, end, loader);
25.58 + if (pt == null || pt == void.class)
25.59 + parseError(str, "bad argument type");
25.60 + ptypes.add(pt);
25.61 + }
25.62 + ++i[0]; // skip ')'
25.63 + } else {
25.64 + parseError(str, "not a method type");
25.65 + }
25.66 + Class<?> rtype = parseSig(str, i, end, loader);
25.67 + if (rtype == null || i[0] != end)
25.68 + parseError(str, "bad return type");
25.69 + ptypes.add(rtype);
25.70 + return ptypes;
25.71 + }
25.72 +
25.73 + static private void parseError(String str, String msg) {
25.74 + throw new IllegalArgumentException("bad signature: "+str+": "+msg);
25.75 + }
25.76 +
25.77 + static private Class<?> parseSig(String str, int[] i, int end, ClassLoader loader) {
25.78 + if (i[0] == end) return null;
25.79 + char c = str.charAt(i[0]++);
25.80 + if (c == 'L') {
25.81 + int begc = i[0], endc = str.indexOf(';', begc);
25.82 + if (endc < 0) return null;
25.83 + i[0] = endc+1;
25.84 + String name = str.substring(begc, endc).replace('/', '.');
25.85 + try {
25.86 + return loader.loadClass(name);
25.87 + } catch (ClassNotFoundException ex) {
25.88 + throw new TypeNotPresentException(name, ex);
25.89 + }
25.90 + } else if (c == '[') {
25.91 + Class<?> t = parseSig(str, i, end, loader);
25.92 + if (t != null)
25.93 + t = java.lang.reflect.Array.newInstance(t, 0).getClass();
25.94 + return t;
25.95 + } else {
25.96 + return Wrapper.forBasicType(c).primitiveType();
25.97 + }
25.98 + }
25.99 +
25.100 + public static String unparse(Class<?> type) {
25.101 + StringBuilder sb = new StringBuilder();
25.102 + unparseSig(type, sb);
25.103 + return sb.toString();
25.104 + }
25.105 +
25.106 + public static String unparse(MethodType type) {
25.107 + return unparseMethod(type.returnType(), type.parameterList());
25.108 + }
25.109 +
25.110 + public static String unparse(Object type) {
25.111 + if (type instanceof Class<?>)
25.112 + return unparse((Class<?>) type);
25.113 + if (type instanceof MethodType)
25.114 + return unparse((MethodType) type);
25.115 + return (String) type;
25.116 + }
25.117 +
25.118 + public static String unparseMethod(Class<?> rtype, List<Class<?>> ptypes) {
25.119 + StringBuilder sb = new StringBuilder();
25.120 + sb.append('(');
25.121 + for (Class<?> pt : ptypes)
25.122 + unparseSig(pt, sb);
25.123 + sb.append(')');
25.124 + unparseSig(rtype, sb);
25.125 + return sb.toString();
25.126 + }
25.127 +
25.128 + static private void unparseSig(Class<?> t, StringBuilder sb) {
25.129 + char c = Wrapper.forBasicType(t).basicTypeChar();
25.130 + if (c != 'L') {
25.131 + sb.append(c);
25.132 + } else {
25.133 + boolean lsemi = (!t.isArray());
25.134 + if (lsemi) sb.append('L');
25.135 + sb.append(t.getName().replace('.', '/'));
25.136 + if (lsemi) sb.append(';');
25.137 + }
25.138 + }
25.139 +
25.140 +}
26.1 --- a/src/share/classes/sun/dyn/util/BytecodeName.java Tue Jan 05 10:40:44 2010 +0800
26.2 +++ b/src/share/classes/sun/dyn/util/BytecodeName.java Wed Jan 13 15:16:06 2010 -0800
26.3 @@ -298,6 +298,8 @@
26.4 * The name {@code <init>} will be parsed into { '<', "init", '>'}}
26.5 * The name {@code foo/bar$:baz} will be parsed into
26.6 * {@code {"foo", '/', "bar", '$', ':', "baz"}}.
26.7 + * The name {@code ::\=:foo:\=bar\!baz} will be parsed into
26.8 + * {@code {':', ':', "", ':', "foo", ':', "bar:baz"}}.
26.9 */
26.10 public static Object[] parseBytecodeName(String s) {
26.11 int slen = s.length();
26.12 @@ -315,7 +317,7 @@
26.13 if (lasti < i) {
26.14 // normal component
26.15 if (pass != 0)
26.16 - res[fillp] = s.substring(lasti, i);
26.17 + res[fillp] = toSourceName(s.substring(lasti, i));
26.18 fillp++;
26.19 lasti = i+1;
26.20 }
26.21 @@ -323,13 +325,14 @@
26.22 if (pass != 0)
26.23 res[fillp] = DANGEROUS_CHARS_CA[whichDC];
26.24 fillp++;
26.25 + lasti = i+1;
26.26 }
26.27 }
26.28 if (pass != 0) break;
26.29 // between passes, build the result array
26.30 - res = new String[fillp];
26.31 - if (fillp <= 1) {
26.32 - if (fillp != 0) res[0] = s;
26.33 + res = new Object[fillp];
26.34 + if (fillp <= 1 && lasti == 0) {
26.35 + if (fillp != 0) res[0] = toSourceName(s);
26.36 break;
26.37 }
26.38 }
26.39 @@ -348,9 +351,19 @@
26.40 * @throws NullPointerException if any component is null
26.41 */
26.42 public static String unparseBytecodeName(Object[] components) {
26.43 - for (Object c : components) {
26.44 - if (c instanceof String)
26.45 - checkSafeBytecodeName((String) c); // may fail
26.46 + Object[] components0 = components;
26.47 + for (int i = 0; i < components.length; i++) {
26.48 + Object c = components[i];
26.49 + if (c instanceof String) {
26.50 + String mc = toBytecodeName((String) c);
26.51 + if (i == 0 && components.length == 1)
26.52 + return mc; // usual case
26.53 + if ((Object)mc != c) {
26.54 + if (components == components0)
26.55 + components = components.clone();
26.56 + components[i] = c = mc;
26.57 + }
26.58 + }
26.59 }
26.60 return appendAll(components);
26.61 }
26.62 @@ -381,6 +394,14 @@
26.63 * If the bytecode name contains dangerous characters,
26.64 * assume that they are being used as punctuation,
26.65 * and pass them through unchanged.
26.66 + * Non-empty runs of non-dangerous characters are demangled
26.67 + * if necessary, and the resulting names are quoted if
26.68 + * they are not already valid Java identifiers, or if
26.69 + * they contain a dangerous character (i.e., dollar sign "$").
26.70 + * Single quotes are used when quoting.
26.71 + * Within quoted names, embedded single quotes and backslashes
26.72 + * are further escaped by prepended backslashes.
26.73 + *
26.74 * @param s the original bytecode name (which may be qualified)
26.75 * @return a human-readable presentation
26.76 */
26.77 @@ -389,10 +410,10 @@
26.78 for (int i = 0; i < components.length; i++) {
26.79 if (!(components[i] instanceof String))
26.80 continue;
26.81 - String c = (String) components[i];
26.82 - // pretty up the name by demangling it
26.83 - String sn = toSourceName(c);
26.84 - if ((Object)sn != c || !isJavaIdent(sn)) {
26.85 + String sn = (String) components[i];
26.86 + // note that the name is already demangled!
26.87 + //sn = toSourceName(sn);
26.88 + if (!isJavaIdent(sn) || sn.indexOf('$') >=0 ) {
26.89 components[i] = quoteDisplay(sn);
26.90 }
26.91 }
26.92 @@ -401,10 +422,10 @@
26.93 private static boolean isJavaIdent(String s) {
26.94 int slen = s.length();
26.95 if (slen == 0) return false;
26.96 - if (!Character.isUnicodeIdentifierStart(s.charAt(0)))
26.97 + if (!Character.isJavaIdentifierStart(s.charAt(0)))
26.98 return false;
26.99 for (int i = 1; i < slen; i++) {
26.100 - if (!Character.isUnicodeIdentifierPart(s.charAt(0)))
26.101 + if (!Character.isJavaIdentifierPart(s.charAt(i)))
26.102 return false;
26.103 }
26.104 return true;
26.105 @@ -602,110 +623,5 @@
26.106 return -1;
26.107 }
26.108
26.109 - // test driver
26.110 - static void main(String[] av) {
26.111 - // If verbose is enabled, quietly check everything.
26.112 - // Otherwise, print the output for the user to check.
26.113 - boolean verbose = false;
26.114
26.115 - int maxlen = 0;
26.116 -
26.117 - while (av.length > 0 && av[0].startsWith("-")) {
26.118 - String flag = av[0].intern();
26.119 - av = java.util.Arrays.copyOfRange(av, 1, av.length); // Java 1.6 or later
26.120 - if (flag == "-" || flag == "--") break;
26.121 - else if (flag == "-q")
26.122 - verbose = false;
26.123 - else if (flag == "-v")
26.124 - verbose = true;
26.125 - else if (flag.startsWith("-l"))
26.126 - maxlen = Integer.valueOf(flag.substring(2));
26.127 - else
26.128 - throw new Error("Illegal flag argument: "+flag);
26.129 - }
26.130 -
26.131 - if (maxlen == 0)
26.132 - maxlen = (verbose ? 2 : 4);
26.133 - if (verbose) System.out.println("Note: maxlen = "+maxlen);
26.134 -
26.135 - switch (av.length) {
26.136 - case 0: av = new String[] {
26.137 - DANGEROUS_CHARS.substring(0) +
26.138 - REPLACEMENT_CHARS.substring(0, 1) +
26.139 - NULL_ESCAPE + "x"
26.140 - }; // and fall through:
26.141 - case 1:
26.142 - char[] cv = av[0].toCharArray();
26.143 - av = new String[cv.length];
26.144 - int avp = 0;
26.145 - for (char c : cv) {
26.146 - String s = String.valueOf(c);
26.147 - if (c == 'x') s = "foo"; // tradition...
26.148 - av[avp++] = s;
26.149 - }
26.150 - }
26.151 - if (verbose)
26.152 - System.out.println("Note: Verbose output mode enabled. Use '-q' to suppress.");
26.153 - Tester t = new Tester();
26.154 - t.maxlen = maxlen;
26.155 - t.verbose = verbose;
26.156 - t.tokens = av;
26.157 - t.test("", 0);
26.158 - }
26.159 -
26.160 - static class Tester {
26.161 - boolean verbose;
26.162 - int maxlen;
26.163 - java.util.Map<String,String> map = new java.util.HashMap<String,String>();
26.164 - String[] tokens;
26.165 -
26.166 - void test(String stringSoFar, int tokensSoFar) {
26.167 - test(stringSoFar);
26.168 - if (tokensSoFar <= maxlen) {
26.169 - for (String token : tokens) {
26.170 - if (token.length() == 0) continue; // skip empty tokens
26.171 - if (stringSoFar.indexOf(token) != stringSoFar.lastIndexOf(token))
26.172 - continue; // there are already two occs. of this token
26.173 - if (token.charAt(0) == ESCAPE_C && token.length() == 1 && maxlen < 4)
26.174 - test(stringSoFar+token, tokensSoFar); // want lots of \'s
26.175 - else if (tokensSoFar < maxlen)
26.176 - test(stringSoFar+token, tokensSoFar+1);
26.177 - }
26.178 - }
26.179 - }
26.180 -
26.181 - void test(String s) {
26.182 - // for small batches, do not test the null string
26.183 - if (s.length() == 0 && maxlen >=1 && maxlen <= 2) return;
26.184 - String bn = testSourceName(s);
26.185 - if (bn == null) return;
26.186 - if (bn == s) {
26.187 - //if (verbose) System.out.println(s+" == id");
26.188 - } else {
26.189 - if (verbose) System.out.println(s+" => "+bn+" "+toDisplayName(bn));
26.190 - String bnbn = testSourceName(bn);
26.191 - if (bnbn == null) return;
26.192 - if (verbose) System.out.println(bn+" => "+bnbn+" "+toDisplayName(bnbn));
26.193 - /*
26.194 - String bn3 = testSourceName(bnbn);
26.195 - if (bn3 == null) return;
26.196 - if (verbose) System.out.println(bnbn+" => "+bn3);
26.197 - */
26.198 - }
26.199 - }
26.200 -
26.201 - String testSourceName(String s) {
26.202 - if (map.containsKey(s)) return null;
26.203 - String bn = toBytecodeName(s);
26.204 - map.put(s, bn);
26.205 - String sn = toSourceName(bn);
26.206 - if (!sn.equals(s)) {
26.207 - String bad = (s+" => "+bn+" != "+sn);
26.208 - if (!verbose) throw new Error("Bad mangling: "+bad);
26.209 - System.out.println("*** "+bad);
26.210 - return null;
26.211 - }
26.212 - return bn;
26.213 - }
26.214 - }
26.215 }
27.1 --- a/src/share/classes/sun/dyn/util/BytecodeSignature.java Tue Jan 05 10:40:44 2010 +0800
27.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
27.3 @@ -1,137 +0,0 @@
27.4 -/*
27.5 - * Copyright 2008-2009 Sun Microsystems, Inc. All Rights Reserved.
27.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
27.7 - *
27.8 - * This code is free software; you can redistribute it and/or modify it
27.9 - * under the terms of the GNU General Public License version 2 only, as
27.10 - * published by the Free Software Foundation. Sun designates this
27.11 - * particular file as subject to the "Classpath" exception as provided
27.12 - * by Sun in the LICENSE file that accompanied this code.
27.13 - *
27.14 - * This code is distributed in the hope that it will be useful, but WITHOUT
27.15 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
27.16 - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
27.17 - * version 2 for more details (a copy is included in the LICENSE file that
27.18 - * accompanied this code).
27.19 - *
27.20 - * You should have received a copy of the GNU General Public License version
27.21 - * 2 along with this work; if not, write to the Free Software Foundation,
27.22 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
27.23 - *
27.24 - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
27.25 - * CA 95054 USA or visit www.sun.com if you need additional information or
27.26 - * have any questions.
27.27 - */
27.28 -
27.29 -package sun.dyn.util;
27.30 -
27.31 -import java.dyn.MethodType;
27.32 -import java.util.ArrayList;
27.33 -import java.util.List;
27.34 -
27.35 -/**
27.36 - * Utility routines for dealing with bytecode-level signatures.
27.37 - * @author jrose
27.38 - */
27.39 -public class BytecodeSignature {
27.40 -
27.41 - private BytecodeSignature() { } // cannot instantiate
27.42 -
27.43 - public static List<Class<?>> parseMethod(String bytecodeSignature, ClassLoader loader) {
27.44 - return parseMethod(bytecodeSignature, 0, bytecodeSignature.length(), loader);
27.45 - }
27.46 -
27.47 - static List<Class<?>> parseMethod(String bytecodeSignature,
27.48 - int start, int end, ClassLoader loader) {
27.49 - if (loader == null)
27.50 - loader = ClassLoader.getSystemClassLoader();
27.51 - String str = bytecodeSignature;
27.52 - int[] i = {start};
27.53 - ArrayList<Class<?>> ptypes = new ArrayList<Class<?>>();
27.54 - if (i[0] < end && str.charAt(i[0]) == '(') {
27.55 - ++i[0]; // skip '('
27.56 - while (i[0] < end && str.charAt(i[0]) != ')') {
27.57 - Class<?> pt = parseSig(str, i, end, loader);
27.58 - if (pt == null || pt == void.class)
27.59 - parseError(str, "bad argument type");
27.60 - ptypes.add(pt);
27.61 - }
27.62 - ++i[0]; // skip ')'
27.63 - } else {
27.64 - parseError(str, "not a method type");
27.65 - }
27.66 - Class<?> rtype = parseSig(str, i, end, loader);
27.67 - if (rtype == null || i[0] != end)
27.68 - parseError(str, "bad return type");
27.69 - ptypes.add(rtype);
27.70 - return ptypes;
27.71 - }
27.72 -
27.73 - static private void parseError(String str, String msg) {
27.74 - throw new IllegalArgumentException("bad signature: "+str+": "+msg);
27.75 - }
27.76 -
27.77 - static private Class<?> parseSig(String str, int[] i, int end, ClassLoader loader) {
27.78 - if (i[0] == end) return null;
27.79 - char c = str.charAt(i[0]++);
27.80 - if (c == 'L') {
27.81 - int begc = i[0], endc = str.indexOf(';', begc);
27.82 - if (endc < 0) return null;
27.83 - i[0] = endc+1;
27.84 - String name = str.substring(begc, endc).replace('/', '.');
27.85 - try {
27.86 - return loader.loadClass(name);
27.87 - } catch (ClassNotFoundException ex) {
27.88 - throw new TypeNotPresentException(name, ex);
27.89 - }
27.90 - } else if (c == '[') {
27.91 - Class<?> t = parseSig(str, i, end, loader);
27.92 - if (t != null)
27.93 - t = java.lang.reflect.Array.newInstance(t, 0).getClass();
27.94 - return t;
27.95 - } else {
27.96 - return Wrapper.forBasicType(c).primitiveType();
27.97 - }
27.98 - }
27.99 -
27.100 - public static String unparse(Class<?> type) {
27.101 - StringBuilder sb = new StringBuilder();
27.102 - unparseSig(type, sb);
27.103 - return sb.toString();
27.104 - }
27.105 -
27.106 - public static String unparse(MethodType type) {
27.107 - return unparseMethod(type.returnType(), type.parameterList());
27.108 - }
27.109 -
27.110 - public static String unparse(Object type) {
27.111 - if (type instanceof Class<?>)
27.112 - return unparse((Class<?>) type);
27.113 - if (type instanceof MethodType)
27.114 - return unparse((MethodType) type);
27.115 - return (String) type;
27.116 - }
27.117 -
27.118 - public static String unparseMethod(Class<?> rtype, List<Class<?>> ptypes) {
27.119 - StringBuilder sb = new StringBuilder();
27.120 - sb.append('(');
27.121 - for (Class<?> pt : ptypes)
27.122 - unparseSig(pt, sb);
27.123 - sb.append(')');
27.124 - unparseSig(rtype, sb);
27.125 - return sb.toString();
27.126 - }
27.127 -
27.128 - static private void unparseSig(Class<?> t, StringBuilder sb) {
27.129 - char c = Wrapper.forBasicType(t).basicTypeChar();
27.130 - if (c != 'L') {
27.131 - sb.append(c);
27.132 - } else {
27.133 - boolean lsemi = (!t.isArray());
27.134 - if (lsemi) sb.append('L');
27.135 - sb.append(t.getName().replace('.', '/'));
27.136 - if (lsemi) sb.append(';');
27.137 - }
27.138 - }
27.139 -
27.140 -}
28.1 --- a/src/share/classes/sun/dyn/util/ValueConversions.java Tue Jan 05 10:40:44 2010 +0800
28.2 +++ b/src/share/classes/sun/dyn/util/ValueConversions.java Wed Jan 13 15:16:06 2010 -0800
28.3 @@ -27,7 +27,10 @@
28.4
28.5 import java.dyn.*;
28.6 import java.dyn.MethodHandles.Lookup;
28.7 +import java.util.ArrayList;
28.8 +import java.util.Arrays;
28.9 import java.util.EnumMap;
28.10 +import java.util.List;
28.11 import sun.dyn.Access;
28.12 import sun.dyn.AdapterMethodHandle;
28.13 import sun.dyn.MethodHandleImpl;
28.14 @@ -37,6 +40,7 @@
28.15 private static final Lookup IMPL_LOOKUP = MethodHandleImpl.getLookup(IMPL_TOKEN);
28.16
28.17 private static EnumMap<Wrapper, MethodHandle>[] newWrapperCaches(int n) {
28.18 + @SuppressWarnings("unchecked")
28.19 EnumMap<Wrapper, MethodHandle>[] caches
28.20 = (EnumMap<Wrapper, MethodHandle>[]) new EnumMap[n]; // unchecked warning expected here
28.21 for (int i = 0; i < n; i++)
28.22 @@ -114,7 +118,7 @@
28.23 }
28.24
28.25 private static MethodType unboxType(Wrapper wrap, boolean raw) {
28.26 - return MethodType.make(rawWrapper(wrap, raw).primitiveType(), wrap.wrapperType());
28.27 + return MethodType.methodType(rawWrapper(wrap, raw).primitiveType(), wrap.wrapperType());
28.28 }
28.29
28.30 private static final EnumMap<Wrapper, MethodHandle>[]
28.31 @@ -240,7 +244,7 @@
28.32 private static MethodType boxType(Wrapper wrap, boolean raw) {
28.33 // be exact, since return casts are hard to compose
28.34 Class<?> boxType = wrap.wrapperType();
28.35 - return MethodType.make(boxType, rawWrapper(wrap, raw).primitiveType());
28.36 + return MethodType.methodType(boxType, rawWrapper(wrap, raw).primitiveType());
28.37 }
28.38
28.39 private static Wrapper rawWrapper(Wrapper wrap, boolean raw) {
28.40 @@ -305,29 +309,47 @@
28.41
28.42 /// Kludges for when raw values get accidentally boxed.
28.43
28.44 + static int unboxRawInteger(Object x) {
28.45 + if (x instanceof Integer)
28.46 + return unboxInteger(x);
28.47 + else
28.48 + return (int) unboxLong(x);
28.49 + }
28.50 +
28.51 + static Integer reboxRawInteger(Object x) {
28.52 + if (x instanceof Integer)
28.53 + return (Integer) x;
28.54 + else
28.55 + return (int) unboxLong(x);
28.56 + }
28.57 +
28.58 static Byte reboxRawByte(Object x) {
28.59 if (x instanceof Byte) return (Byte) x;
28.60 - return boxByteRaw(unboxInteger(x));
28.61 + return boxByteRaw(unboxRawInteger(x));
28.62 }
28.63
28.64 static Short reboxRawShort(Object x) {
28.65 if (x instanceof Short) return (Short) x;
28.66 - return boxShortRaw(unboxInteger(x));
28.67 + return boxShortRaw(unboxRawInteger(x));
28.68 }
28.69
28.70 static Boolean reboxRawBoolean(Object x) {
28.71 if (x instanceof Boolean) return (Boolean) x;
28.72 - return boxBooleanRaw(unboxInteger(x));
28.73 + return boxBooleanRaw(unboxRawInteger(x));
28.74 }
28.75
28.76 static Character reboxRawCharacter(Object x) {
28.77 if (x instanceof Character) return (Character) x;
28.78 - return boxCharacterRaw(unboxInteger(x));
28.79 + return boxCharacterRaw(unboxRawInteger(x));
28.80 }
28.81
28.82 static Float reboxRawFloat(Object x) {
28.83 if (x instanceof Float) return (Float) x;
28.84 - return boxFloatRaw(unboxInteger(x));
28.85 + return boxFloatRaw(unboxRawInteger(x));
28.86 + }
28.87 +
28.88 + static Long reboxRawLong(Object x) {
28.89 + return (Long) x; //never a rebox
28.90 }
28.91
28.92 static Double reboxRawDouble(Object x) {
28.93 @@ -337,12 +359,21 @@
28.94
28.95 private static MethodType reboxType(Wrapper wrap) {
28.96 Class<?> boxType = wrap.wrapperType();
28.97 - return MethodType.make(boxType, Object.class);
28.98 + return MethodType.methodType(boxType, Object.class);
28.99 }
28.100
28.101 private static final EnumMap<Wrapper, MethodHandle>[]
28.102 REBOX_CONVERSIONS = newWrapperCaches(2);
28.103
28.104 + /**
28.105 + * Becase we normalize primitive types to reduce the number of signatures,
28.106 + * primitives are sometimes manipulated under an "erased" type,
28.107 + * either int (for types other than long/double) or long (for all types).
28.108 + * When the erased primitive value is then boxed into an Integer or Long,
28.109 + * the final boxed primitive is sometimes required. This transformation
28.110 + * is called a "rebox". It takes an Integer or Long and produces some
28.111 + * other boxed value.
28.112 + */
28.113 public static MethodHandle rebox(Wrapper wrap, boolean exact) {
28.114 EnumMap<Wrapper, MethodHandle> cache = REBOX_CONVERSIONS[exact?1:0];
28.115 MethodHandle mh = cache.get(wrap);
28.116 @@ -355,9 +386,6 @@
28.117 mh = IDENTITY; break;
28.118 case VOID:
28.119 throw new IllegalArgumentException("cannot rebox a void");
28.120 - case INT: case LONG:
28.121 - mh = cast(wrap.wrapperType(), exact);
28.122 - break;
28.123 }
28.124 if (mh != null) {
28.125 cache.put(wrap, mh);
28.126 @@ -384,13 +412,21 @@
28.127 /// Width-changing conversions between int and long.
28.128
28.129 static long widenInt(int x) {
28.130 - return x;
28.131 + return (long) x;
28.132 + }
28.133 +
28.134 + static Long widenBoxedInt(Integer x) {
28.135 + return (long)(int)x;
28.136 }
28.137
28.138 static int narrowLong(long x) {
28.139 return (int) x;
28.140 }
28.141
28.142 + static Integer narrowBoxedLong(Long x) {
28.143 + return (int)(long) x;
28.144 + }
28.145 +
28.146 /// Constant functions
28.147
28.148 static void ignore(Object x) {
28.149 @@ -432,7 +468,7 @@
28.150 return mh;
28.151 }
28.152 // slow path
28.153 - MethodType type = MethodType.make(wrap.primitiveType());
28.154 + MethodType type = MethodType.methodType(wrap.primitiveType());
28.155 switch (wrap) {
28.156 case VOID:
28.157 mh = EMPTY;
28.158 @@ -500,11 +536,11 @@
28.159 private static final MethodHandle IDENTITY, CAST_REFERENCE, ALWAYS_NULL, ALWAYS_ZERO, ZERO_OBJECT, IGNORE, EMPTY;
28.160 static {
28.161 try {
28.162 - MethodType idType = MethodType.makeGeneric(1);
28.163 - MethodType castType = idType.insertParameterType(0, Class.class);
28.164 + MethodType idType = MethodType.genericMethodType(1);
28.165 + MethodType castType = idType.insertParameterTypes(0, Class.class);
28.166 MethodType alwaysZeroType = idType.changeReturnType(int.class);
28.167 MethodType ignoreType = idType.changeReturnType(void.class);
28.168 - MethodType zeroObjectType = MethodType.makeGeneric(0);
28.169 + MethodType zeroObjectType = MethodType.genericMethodType(0);
28.170 IDENTITY = IMPL_LOOKUP.findStatic(ValueConversions.class, "identity", idType);
28.171 //CAST_REFERENCE = IMPL_LOOKUP.findVirtual(Class.class, "cast", idType);
28.172 CAST_REFERENCE = IMPL_LOOKUP.findStatic(ValueConversions.class, "castReference", castType);
28.173 @@ -512,7 +548,7 @@
28.174 ALWAYS_ZERO = IMPL_LOOKUP.findStatic(ValueConversions.class, "alwaysZero", alwaysZeroType);
28.175 ZERO_OBJECT = IMPL_LOOKUP.findStatic(ValueConversions.class, "zeroObject", zeroObjectType);
28.176 IGNORE = IMPL_LOOKUP.findStatic(ValueConversions.class, "ignore", ignoreType);
28.177 - EMPTY = IMPL_LOOKUP.findStatic(ValueConversions.class, "empty", ignoreType.dropParameterType(0));
28.178 + EMPTY = IMPL_LOOKUP.findStatic(ValueConversions.class, "empty", ignoreType.dropParameterTypes(0, 1));
28.179 } catch (RuntimeException ex) {
28.180 throw ex;
28.181 }
28.182 @@ -543,10 +579,10 @@
28.183 else if (VerifyType.isNullType(type))
28.184 mh = ALWAYS_NULL;
28.185 else
28.186 - mh = MethodHandles.insertArgument(CAST_REFERENCE, 0, type);
28.187 + mh = MethodHandles.insertArguments(CAST_REFERENCE, 0, type);
28.188 if (exact) {
28.189 - MethodType xmt = MethodType.make(type, Object.class);
28.190 - mh = AdapterMethodHandle.makeRawRetypeOnly(IMPL_TOKEN, xmt, mh);
28.191 + MethodType xmt = MethodType.methodType(type, Object.class);
28.192 + mh = AdapterMethodHandle.makeRetypeRaw(IMPL_TOKEN, xmt, mh);
28.193 }
28.194 if (cache != null)
28.195 cache.put(wrap, mh);
28.196 @@ -560,4 +596,127 @@
28.197 private static MethodHandle retype(MethodType type, MethodHandle mh) {
28.198 return AdapterMethodHandle.makeRetypeOnly(IMPL_TOKEN, type, mh);
28.199 }
28.200 +
28.201 + private static final Object[] NO_ARGS_ARRAY = {};
28.202 + private static Object[] makeArray(Object... args) { return args; }
28.203 + private static Object[] array() { return NO_ARGS_ARRAY; }
28.204 + private static Object[] array(Object a0)
28.205 + { return makeArray(a0); }
28.206 + private static Object[] array(Object a0, Object a1)
28.207 + { return makeArray(a0, a1); }
28.208 + private static Object[] array(Object a0, Object a1, Object a2)
28.209 + { return makeArray(a0, a1, a2); }
28.210 + private static Object[] array(Object a0, Object a1, Object a2, Object a3)
28.211 + { return makeArray(a0, a1, a2, a3); }
28.212 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.213 + Object a4)
28.214 + { return makeArray(a0, a1, a2, a3, a4); }
28.215 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.216 + Object a4, Object a5)
28.217 + { return makeArray(a0, a1, a2, a3, a4, a5); }
28.218 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.219 + Object a4, Object a5, Object a6)
28.220 + { return makeArray(a0, a1, a2, a3, a4, a5, a6); }
28.221 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.222 + Object a4, Object a5, Object a6, Object a7)
28.223 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7); }
28.224 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.225 + Object a4, Object a5, Object a6, Object a7,
28.226 + Object a8)
28.227 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
28.228 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
28.229 + Object a4, Object a5, Object a6, Object a7,
28.230 + Object a8, Object a9)
28.231 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
28.232 + static MethodHandle[] makeArrays() {
28.233 + ArrayList<MethodHandle> arrays = new ArrayList<MethodHandle>();
28.234 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
28.235 + for (;;) {
28.236 + int nargs = arrays.size();
28.237 + MethodType type = MethodType.genericMethodType(nargs).changeReturnType(Object[].class);
28.238 + String name = "array";
28.239 + MethodHandle array = null;
28.240 + try {
28.241 + array = lookup.findStatic(ValueConversions.class, name, type);
28.242 + } catch (NoAccessException ex) {
28.243 + }
28.244 + if (array == null) break;
28.245 + arrays.add(array);
28.246 + }
28.247 + assert(arrays.size() == 11); // current number of methods
28.248 + return arrays.toArray(new MethodHandle[0]);
28.249 + }
28.250 + static final MethodHandle[] ARRAYS = makeArrays();
28.251 +
28.252 + /** Return a method handle that takes the indicated number of Object
28.253 + * arguments and returns an Object array of them, as if for varargs.
28.254 + */
28.255 + public static MethodHandle varargsArray(int nargs) {
28.256 + if (nargs < ARRAYS.length)
28.257 + return ARRAYS[nargs];
28.258 + // else need to spin bytecode or do something else fancy
28.259 + throw new UnsupportedOperationException("NYI");
28.260 + }
28.261 +
28.262 + private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);
28.263 + private static List<Object> makeList(Object... args) { return Arrays.asList(args); }
28.264 + private static List<Object> list() { return NO_ARGS_LIST; }
28.265 + private static List<Object> list(Object a0)
28.266 + { return makeList(a0); }
28.267 + private static List<Object> list(Object a0, Object a1)
28.268 + { return makeList(a0, a1); }
28.269 + private static List<Object> list(Object a0, Object a1, Object a2)
28.270 + { return makeList(a0, a1, a2); }
28.271 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3)
28.272 + { return makeList(a0, a1, a2, a3); }
28.273 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.274 + Object a4)
28.275 + { return makeList(a0, a1, a2, a3, a4); }
28.276 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.277 + Object a4, Object a5)
28.278 + { return makeList(a0, a1, a2, a3, a4, a5); }
28.279 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.280 + Object a4, Object a5, Object a6)
28.281 + { return makeList(a0, a1, a2, a3, a4, a5, a6); }
28.282 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.283 + Object a4, Object a5, Object a6, Object a7)
28.284 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7); }
28.285 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.286 + Object a4, Object a5, Object a6, Object a7,
28.287 + Object a8)
28.288 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
28.289 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
28.290 + Object a4, Object a5, Object a6, Object a7,
28.291 + Object a8, Object a9)
28.292 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
28.293 + static MethodHandle[] makeLists() {
28.294 + ArrayList<MethodHandle> arrays = new ArrayList<MethodHandle>();
28.295 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
28.296 + for (;;) {
28.297 + int nargs = arrays.size();
28.298 + MethodType type = MethodType.genericMethodType(nargs).changeReturnType(List.class);
28.299 + String name = "list";
28.300 + MethodHandle array = null;
28.301 + try {
28.302 + array = lookup.findStatic(ValueConversions.class, name, type);
28.303 + } catch (NoAccessException ex) {
28.304 + }
28.305 + if (array == null) break;
28.306 + arrays.add(array);
28.307 + }
28.308 + assert(arrays.size() == 11); // current number of methods
28.309 + return arrays.toArray(new MethodHandle[0]);
28.310 + }
28.311 + static final MethodHandle[] LISTS = makeLists();
28.312 +
28.313 + /** Return a method handle that takes the indicated number of Object
28.314 + * arguments and returns List.
28.315 + */
28.316 + public static MethodHandle varargsList(int nargs) {
28.317 + if (nargs < LISTS.length)
28.318 + return LISTS[nargs];
28.319 + // else need to spin bytecode or do something else fancy
28.320 + throw new UnsupportedOperationException("NYI");
28.321 + }
28.322 }
28.323 +
29.1 --- a/src/share/classes/sun/dyn/util/VerifyAccess.java Tue Jan 05 10:40:44 2010 +0800
29.2 +++ b/src/share/classes/sun/dyn/util/VerifyAccess.java Wed Jan 13 15:16:06 2010 -0800
29.3 @@ -26,8 +26,12 @@
29.4 package sun.dyn.util;
29.5
29.6 import java.dyn.LinkagePermission;
29.7 +import java.dyn.MethodHandles.Lookup;
29.8 +import java.dyn.NoAccessException;
29.9 import java.lang.reflect.Modifier;
29.10 -import sun.dyn.Access;
29.11 +import sun.dyn.MemberName;
29.12 +import sun.dyn.MethodHandleImpl;
29.13 +import sun.dyn.empty.Empty;
29.14
29.15 /**
29.16 * This class centralizes information about the JVM's linkage access control.
29.17 @@ -45,21 +49,21 @@
29.18 * <p>
29.19 * Some circumstances require an additional check on the
29.20 * leading parameter (the receiver) of the method, if it is non-static.
29.21 - * In the case of {@code invokespecial} ({@code doDispatch} is false),
29.22 + * In the case of {@code invokespecial} ({@code isSpecialInvoke} is true),
29.23 * the leading parameter must be the accessing class or a subclass.
29.24 * In the case of a call to a {@code protected} method outside the same
29.25 * package, the same constraint applies.
29.26 * @param m the proposed callee
29.27 - * @param doDispatch if false, a non-static m will be invoked as if by {@code invokespecial}
29.28 + * @param isSpecialInvoke if true, a non-static method m is checked as if for {@code invokespecial}
29.29 * @param lookupClass the class for which the access check is being made
29.30 * @return null if the method is not accessible, else a receiver type constraint, else {@code Object.class}
29.31 */
29.32 public static Class<?> isAccessible(Class<?> defc, int mods,
29.33 - boolean doDispatch, Class<?> lookupClass) {
29.34 + Class<?> lookupClass, boolean isSpecialInvoke) {
29.35 if (!isAccessible(defc, lookupClass))
29.36 return null;
29.37 Class<?> constraint = Object.class;
29.38 - if (!doDispatch && !Modifier.isStatic(mods)) {
29.39 + if (isSpecialInvoke && !Modifier.isStatic(mods)) {
29.40 constraint = lookupClass;
29.41 }
29.42 if (Modifier.isPublic(mods))
29.43 @@ -166,4 +170,38 @@
29.44 if (isSamePackage(requestingClass, subjectClass)) return;
29.45 security.checkPermission(new LinkagePermission(permissionName, requestingClass));
29.46 }
29.47 +
29.48 + private static RuntimeException checkNameFailed(MemberName self, Lookup lookup, String comment) {
29.49 + return new NoAccessException("cannot access from "+lookup+": "+self.toString()+": "+comment);
29.50 + }
29.51 + public static void checkName(MemberName self, Lookup lookup) {
29.52 + Class<?> lc = lookup.lookupClass();
29.53 + if (lc == null) return; // lookup is privileged
29.54 + Class<?> dc = self.getDeclaringClass();
29.55 + int samepkg = 0;
29.56 + // First check the containing class. Must be public or local.
29.57 + if (!Modifier.isPublic(dc.getModifiers())) {
29.58 + if (lc != Empty.class)
29.59 + samepkg = (isSamePackage(dc, lc) ? 1 : -1);
29.60 + if (samepkg <= 0)
29.61 + throw checkNameFailed(self, lookup, "class is not public");
29.62 + }
29.63 + // At this point dc is known to be accessible.
29.64 + if (self.isPublic()) {
29.65 + return;
29.66 + } else if (lc == Empty.class) {
29.67 + throw checkNameFailed(self, lookup, "member is not public");
29.68 + } else if (self.isProtected()) {
29.69 + if (dc.isAssignableFrom(lc)) return;
29.70 + } else if (self.isPrivate()) {
29.71 + if (isSamePackageMember(dc, lc)) return;
29.72 + throw checkNameFailed(self, lookup, "member is private");
29.73 + }
29.74 + // Fall-through handles the package-private and protected cases.
29.75 + if (samepkg == 0)
29.76 + samepkg = (isSamePackage(dc, lc) ? 1 : -1);
29.77 + if (samepkg > 0) return;
29.78 + throw checkNameFailed(self, lookup,
29.79 + self.isProtected() ? "member is protected" : "member is private to package");
29.80 + }
29.81 }
30.1 --- a/src/share/classes/sun/dyn/util/VerifyType.java Tue Jan 05 10:40:44 2010 +0800
30.2 +++ b/src/share/classes/sun/dyn/util/VerifyType.java Wed Jan 13 15:16:06 2010 -0800
30.3 @@ -26,6 +26,7 @@
30.4 package sun.dyn.util;
30.5
30.6 import java.dyn.MethodType;
30.7 +import sun.dyn.empty.Empty;
30.8
30.9 /**
30.10 * This class centralizes information about the JVM verifier
30.11 @@ -73,29 +74,28 @@
30.12 }
30.13
30.14 /**
30.15 - * Is the given type either java.lang.Void or java.lang.Null?
30.16 - * These types serve as markers for bare nulls and therefore
30.17 - * may be promoted to any type. This is secure, since
30.18 + * Is the given type java.lang.Null or an equivalent null-only type?
30.19 */
30.20 public static boolean isNullType(Class<?> type) {
30.21 if (type == null) return false;
30.22 - return type == NULL_CLASS_1 || type == NULL_CLASS_2;
30.23 + return type == NULL_CLASS
30.24 + // This one may also be used as a null type.
30.25 + // TO DO: Decide if we really want to legitimize it here.
30.26 + // Probably we do, unless java.lang.Null really makes it into Java 7
30.27 + //|| type == Void.class
30.28 + // Locally known null-only class:
30.29 + || type == Empty.class
30.30 + ;
30.31 }
30.32 - private static final Class<?> NULL_CLASS_1, NULL_CLASS_2;
30.33 + private static final Class<?> NULL_CLASS;
30.34 static {
30.35 - Class<?> nullClass1 = null, nullClass2 = null;
30.36 + Class<?> nullClass = null;
30.37 try {
30.38 - nullClass1 = Class.forName("java.lang.Null");
30.39 + nullClass = Class.forName("java.lang.Null");
30.40 } catch (ClassNotFoundException ex) {
30.41 // OK, we'll cope
30.42 }
30.43 - NULL_CLASS_1 = nullClass1;
30.44 -
30.45 - // This one may also be used as a null type.
30.46 - // TO DO: Decide if we really want to legitimize it here.
30.47 - // Probably we do, unless java.lang.Null really makes it into Java 7
30.48 - nullClass2 = Void.class;
30.49 - NULL_CLASS_2 = nullClass2;
30.50 + NULL_CLASS = nullClass;
30.51 }
30.52
30.53 /**
30.54 @@ -191,6 +191,11 @@
30.55 // to be captured as a garbage int.
30.56 // Caller promises that the actual value will be disregarded.
30.57 return dst == int.class ? 1 : 0;
30.58 + if (isNullType(src))
30.59 + // Special permission for raw conversions: allow a null
30.60 + // to be reinterpreted as anything. For objects, it is safe,
30.61 + // and for primitives you get a garbage value (probably zero).
30.62 + return 1;
30.63 if (!src.isPrimitive())
30.64 return 0;
30.65 Wrapper sw = Wrapper.forPrimitiveType(src);
31.1 --- a/src/share/classes/sun/dyn/util/Wrapper.java Tue Jan 05 10:40:44 2010 +0800
31.2 +++ b/src/share/classes/sun/dyn/util/Wrapper.java Wed Jan 13 15:16:06 2010 -0800
31.3 @@ -141,13 +141,19 @@
31.4 * @throws IllegalArgumentException for unexpected types
31.5 */
31.6 public static Wrapper forPrimitiveType(Class<?> type) {
31.7 + Wrapper w = findPrimitiveType(type);
31.8 + if (w != null) return w;
31.9 + if (type.isPrimitive())
31.10 + throw new InternalError(); // redo hash function
31.11 + throw newIllegalArgumentException("not primitive: "+type);
31.12 + }
31.13 +
31.14 + static Wrapper findPrimitiveType(Class<?> type) {
31.15 Wrapper w = FROM_PRIM[hashPrim(type)];
31.16 if (w != null && w.primitiveType == type) {
31.17 return w;
31.18 }
31.19 - if (type.isPrimitive())
31.20 - throw new InternalError(); // redo hash function
31.21 - throw newIllegalArgumentException("not primitive: "+type);
31.22 + return null;
31.23 }
31.24
31.25 /** Return the wrapper that wraps values into the given wrapper type.
31.26 @@ -160,7 +166,7 @@
31.27 Wrapper w = findWrapperType(type);
31.28 if (w != null) return w;
31.29 for (Wrapper x : values())
31.30 - if (w.wrapperType == type)
31.31 + if (x.wrapperType == type)
31.32 throw new InternalError(); // redo hash function
31.33 throw newIllegalArgumentException("not wrapper: "+type);
31.34 }
31.35 @@ -244,8 +250,10 @@
31.36 public Class<?> wrapperType() { return wrapperType; }
31.37
31.38 /** What is the wrapper type for this wrapper?
31.39 - * The example type must be the wrapper type,
31.40 + * Otherwise, the example type must be the wrapper type,
31.41 * or the corresponding primitive type.
31.42 + * (For {@code OBJECT}, the example type can be any non-primitive,
31.43 + * and is normalized to {@code Object.class}.)
31.44 * The resulting class type has the same type parameter.
31.45 */
31.46 public <T> Class<T> wrapperType(Class<T> exampleType) {
31.47 @@ -290,6 +298,16 @@
31.48 return type.isPrimitive();
31.49 }
31.50
31.51 + /** What is the bytecode signature character for this type?
31.52 + * All non-primitives, including array types, report as 'L', the signature character for references.
31.53 + */
31.54 + public static char basicTypeChar(Class<?> type) {
31.55 + if (!type.isPrimitive())
31.56 + return 'L';
31.57 + else
31.58 + return forPrimitiveType(type).basicTypeChar();
31.59 + }
31.60 +
31.61 /** What is the bytecode signature character for this wrapper's
31.62 * primitive type?
31.63 */
31.64 @@ -309,7 +327,7 @@
31.65 /** Cast a wrapped value to the given type, which may be either a primitive or wrapper type.
31.66 * Performs standard primitive conversions, including truncation and float conversions.
31.67 * The given type must be compatible with this wrapper. That is, it must either
31.68 - * be the wrapper type (or a subtype, in the case of {@code OBJECT} or else
31.69 + * be the wrapper type (or a subtype, in the case of {@code OBJECT}) or else
31.70 * it must be the wrapper's primitive type.
31.71 * @throws ClassCastException if the given type is not compatible with this wrapper
31.72 */
31.73 @@ -326,9 +344,17 @@
31.74 * If the target type is a primitive, change it to a wrapper.
31.75 */
31.76 static <T> Class<T> forceType(Class<?> type, Class<T> exampleType) {
31.77 + boolean z = (type == exampleType ||
31.78 + type.isPrimitive() && forPrimitiveType(type) == findWrapperType(exampleType) ||
31.79 + exampleType.isPrimitive() && forPrimitiveType(exampleType) == findWrapperType(type) ||
31.80 + type == Object.class && !exampleType.isPrimitive());
31.81 + if (!z)
31.82 + System.out.println(type+" <= "+exampleType);
31.83 assert(type == exampleType ||
31.84 - type == asWrapperType(exampleType) ||
31.85 - type == Object.class && exampleType.isInterface());
31.86 + type.isPrimitive() && forPrimitiveType(type) == findWrapperType(exampleType) ||
31.87 + exampleType.isPrimitive() && forPrimitiveType(exampleType) == findWrapperType(type) ||
31.88 + type == Object.class && !exampleType.isPrimitive());
31.89 + @SuppressWarnings("unchecked")
31.90 Class<T> result = (Class<T>) type; // unchecked warning is expected here
31.91 return result;
31.92 }
32.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
32.2 +++ b/test/java/dyn/MethodHandlesTest.java Wed Jan 13 15:16:06 2010 -0800
32.3 @@ -0,0 +1,1839 @@
32.4 +/*
32.5 + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
32.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
32.7 + *
32.8 + * This code is free software; you can redistribute it and/or modify it
32.9 + * under the terms of the GNU General Public License version 2 only, as
32.10 + * published by the Free Software Foundation. Sun designates this
32.11 + * particular file as subject to the "Classpath" exception as provided
32.12 + * by Sun in the LICENSE file that accompanied this code.
32.13 + *
32.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
32.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
32.16 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
32.17 + * version 2 for more details (a copy is included in the LICENSE file that
32.18 + * accompanied this code).
32.19 + *
32.20 + * You should have received a copy of the GNU General Public License version
32.21 + * 2 along with this work; if not, write to the Free Software Foundation,
32.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
32.23 + *
32.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
32.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
32.26 + * have any questions.
32.27 + */
32.28 +
32.29 +/* @test
32.30 + * @summary unit tests for java.dyn.MethodHandles
32.31 + * @compile -XDinvokedynamic MethodHandlesTest.java
32.32 + * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic jdk.java.dyn.MethodHandlesTest
32.33 + */
32.34 +
32.35 +package jdk.java.dyn;
32.36 +
32.37 +import java.dyn.*;
32.38 +import java.dyn.MethodHandles.Lookup;
32.39 +import java.lang.reflect.*;
32.40 +import java.util.*;
32.41 +import java.util.logging.Level;
32.42 +import java.util.logging.Logger;
32.43 +import org.junit.*;
32.44 +import static org.junit.Assert.*;
32.45 +
32.46 +
32.47 +/**
32.48 + *
32.49 + * @author jrose
32.50 + */
32.51 +public class MethodHandlesTest {
32.52 + // How much output?
32.53 + static int verbosity = 1;
32.54 +
32.55 + // Set this true during development if you want to fast-forward to
32.56 + // a particular new, non-working test. Tests which are known to
32.57 + // work (or have recently worked) test this flag and return on true.
32.58 + static boolean CAN_SKIP_WORKING = false;
32.59 + //static { CAN_SKIP_WORKING = true; }
32.60 +
32.61 + // Set true to test more calls. If false, some tests are just
32.62 + // lookups, without exercising the actual method handle.
32.63 + static boolean DO_MORE_CALLS = false;
32.64 +
32.65 +
32.66 + @Test
32.67 + public void testFirst() throws Throwable {
32.68 + verbosity += 9; try {
32.69 + // left blank for debugging
32.70 + } finally { verbosity -= 9; }
32.71 + }
32.72 +
32.73 + // current failures
32.74 + @Test @Ignore("failure in call to makeRawRetypeOnly in ToGeneric")
32.75 + public void testFail_1() throws Throwable {
32.76 + testSpreadArguments(int.class, 0, 6);
32.77 + }
32.78 + @Test @Ignore("failure in JVM when expanding the stack")
32.79 + public void testFail_2() throws Throwable {
32.80 + // if CONV_OP_IMPLEMENTED_MASK includes OP_SPREAD_ARGS, this crashes:
32.81 + testSpreadArguments(Object.class, 0, 2);
32.82 + }
32.83 + @Test @Ignore("IllArgEx failure in call to ToGeneric.make")
32.84 + public void testFail_3() throws Throwable {
32.85 + testSpreadArguments(int.class, 1, 2);
32.86 + }
32.87 + @Test @Ignore("IllArgEx failure in call to ToGeneric.make")
32.88 + public void testFail_4() throws Throwable {
32.89 + testCollectArguments(int.class, 1, 2);
32.90 + }
32.91 + @Test @Ignore("cannot collect leading primitive types")
32.92 + public void testFail_5() throws Throwable {
32.93 + testInvokers(MethodType.genericMethodType(2).changeParameterType(0, int.class));
32.94 + }
32.95 + @Test @Ignore("should not insert arguments beyond MethodHandlePushLimit")
32.96 + public void testFail_6() throws Throwable {
32.97 + testInsertArguments(0, 0, MAX_ARG_INCREASE+1);
32.98 + }
32.99 + static final int MAX_ARG_INCREASE = 3;
32.100 +
32.101 + public MethodHandlesTest() {
32.102 + }
32.103 +
32.104 + String testName;
32.105 + int posTests, negTests;
32.106 + @After
32.107 + public void printCounts() {
32.108 + if (verbosity >= 1 && (posTests | negTests) != 0) {
32.109 + System.out.println();
32.110 + if (posTests != 0) System.out.println("=== "+testName+": "+posTests+" positive test cases run");
32.111 + if (negTests != 0) System.out.println("=== "+testName+": "+negTests+" negative test cases run");
32.112 + }
32.113 + }
32.114 + void countTest(boolean positive) {
32.115 + if (positive) ++posTests;
32.116 + else ++negTests;
32.117 + }
32.118 + void countTest() { countTest(true); }
32.119 + void startTest(String name) {
32.120 + if (testName != null) printCounts();
32.121 + if (verbosity >= 0)
32.122 + System.out.println(name);
32.123 + posTests = negTests = 0;
32.124 + testName = name;
32.125 + }
32.126 +
32.127 + @BeforeClass
32.128 + public static void setUpClass() throws Exception {
32.129 + calledLog.clear();
32.130 + calledLog.add(null);
32.131 + nextArg = 1000000;
32.132 + }
32.133 +
32.134 + @AfterClass
32.135 + public static void tearDownClass() throws Exception {
32.136 + }
32.137 +
32.138 + static List<Object> calledLog = new ArrayList<Object>();
32.139 + static Object logEntry(String name, Object... args) {
32.140 + return Arrays.asList(name, Arrays.asList(args));
32.141 + }
32.142 + static Object called(String name, Object... args) {
32.143 + Object entry = logEntry(name, args);
32.144 + calledLog.add(entry);
32.145 + return entry;
32.146 + }
32.147 + static void assertCalled(String name, Object... args) {
32.148 + Object expected = logEntry(name, args);
32.149 + Object actual = calledLog.get(calledLog.size() - 1);
32.150 + if (expected.equals(actual)) return;
32.151 + System.out.println("assertCalled "+name+":");
32.152 + System.out.println("expected: "+expected);
32.153 + System.out.println("actual: "+actual);
32.154 + System.out.println("ex. types: "+getClasses(expected));
32.155 + System.out.println("act. types: "+getClasses(actual));
32.156 + assertEquals("previous method call types", expected, actual);
32.157 + assertEquals("previous method call", expected, actual);
32.158 + }
32.159 + static void printCalled(MethodHandle target, String name, Object... args) {
32.160 + if (verbosity >= 2)
32.161 + System.out.println("calling "+logEntry(name, args)+" on "+target);
32.162 + }
32.163 +
32.164 + static Object castToWrapper(Object value, Class<?> dst) {
32.165 + Object wrap = null;
32.166 + if (value instanceof Number)
32.167 + wrap = castToWrapperOrNull(((Number)value).longValue(), dst);
32.168 + if (value instanceof Character)
32.169 + wrap = castToWrapperOrNull((char)(Character)value, dst);
32.170 + if (wrap != null) return wrap;
32.171 + return dst.cast(value);
32.172 + }
32.173 +
32.174 + static Object castToWrapperOrNull(long value, Class<?> dst) {
32.175 + if (dst == int.class || dst == Integer.class)
32.176 + return (int)(value);
32.177 + if (dst == long.class || dst == Long.class)
32.178 + return (long)(value);
32.179 + if (dst == char.class || dst == Character.class)
32.180 + return (char)(value);
32.181 + if (dst == short.class || dst == Short.class)
32.182 + return (short)(value);
32.183 + if (dst == float.class || dst == Float.class)
32.184 + return (float)(value);
32.185 + if (dst == double.class || dst == Double.class)
32.186 + return (double)(value);
32.187 + if (dst == byte.class || dst == Byte.class)
32.188 + return (byte)(value);
32.189 + if (dst == boolean.class || dst == boolean.class)
32.190 + return ((value % 29) & 1) == 0;
32.191 + return null;
32.192 + }
32.193 +
32.194 + static int nextArg;
32.195 + static Object randomArg(Class<?> param) {
32.196 + Object wrap = castToWrapperOrNull(nextArg, param);
32.197 + if (wrap != null) {
32.198 + nextArg++;
32.199 + return wrap;
32.200 + }
32.201 +// import sun.dyn.util.Wrapper;
32.202 +// Wrapper wrap = Wrapper.forBasicType(dst);
32.203 +// if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst))
32.204 +// wrap = Wrapper.forWrapperType(dst);
32.205 +// if (wrap != Wrapper.OBJECT)
32.206 +// return wrap.wrap(nextArg++);
32.207 + if (param.isInterface() || param.isAssignableFrom(String.class))
32.208 + return "#"+(nextArg++);
32.209 + else
32.210 + try {
32.211 + return param.newInstance();
32.212 + } catch (InstantiationException ex) {
32.213 + } catch (IllegalAccessException ex) {
32.214 + }
32.215 + return null; // random class not Object, String, Integer, etc.
32.216 + }
32.217 + static Object[] randomArgs(Class<?>... params) {
32.218 + Object[] args = new Object[params.length];
32.219 + for (int i = 0; i < args.length; i++)
32.220 + args[i] = randomArg(params[i]);
32.221 + return args;
32.222 + }
32.223 + static Object[] randomArgs(int nargs, Class<?> param) {
32.224 + Object[] args = new Object[nargs];
32.225 + for (int i = 0; i < args.length; i++)
32.226 + args[i] = randomArg(param);
32.227 + return args;
32.228 + }
32.229 +
32.230 + static <T, E extends T> T[] array(Class<T[]> atype, E... a) {
32.231 + return Arrays.copyOf(a, a.length, atype);
32.232 + }
32.233 + static <T> T[] cat(T[] a, T... b) {
32.234 + int alen = a.length, blen = b.length;
32.235 + if (blen == 0) return a;
32.236 + T[] c = Arrays.copyOf(a, alen + blen);
32.237 + System.arraycopy(b, 0, c, alen, blen);
32.238 + return c;
32.239 + }
32.240 + static Integer[] boxAll(int... vx) {
32.241 + Integer[] res = new Integer[vx.length];
32.242 + for (int i = 0; i < res.length; i++) {
32.243 + res[i] = vx[i];
32.244 + }
32.245 + return res;
32.246 + }
32.247 + static Object getClasses(Object x) {
32.248 + if (x == null) return x;
32.249 + if (x instanceof String) return x; // keep the name
32.250 + if (x instanceof List) {
32.251 + // recursively report classes of the list elements
32.252 + Object[] xa = ((List)x).toArray();
32.253 + for (int i = 0; i < xa.length; i++)
32.254 + xa[i] = getClasses(xa[i]);
32.255 + return Arrays.asList(xa);
32.256 + }
32.257 + return x.getClass().getSimpleName();
32.258 + }
32.259 +
32.260 + static MethodHandle changeArgTypes(MethodHandle target, Class<?> argType) {
32.261 + return changeArgTypes(target, 0, 999, argType);
32.262 + }
32.263 + static MethodHandle changeArgTypes(MethodHandle target,
32.264 + int beg, int end, Class<?> argType) {
32.265 + MethodType targetType = target.type();
32.266 + end = Math.min(end, targetType.parameterCount());
32.267 + ArrayList<Class<?>> argTypes = new ArrayList<Class<?>>(targetType.parameterList());
32.268 + Collections.fill(argTypes.subList(beg, end), argType);
32.269 + MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes);
32.270 + return MethodHandles.convertArguments(target, ttype2);
32.271 + }
32.272 +
32.273 + // This lookup is good for all members in and under MethodHandlesTest.
32.274 + static final Lookup PRIVATE = MethodHandles.lookup();
32.275 + // This lookup is good for package-private members but not private ones.
32.276 + static final Lookup PACKAGE = PackageSibling.lookup();
32.277 + // This lookup is good only for public members.
32.278 + static final Lookup PUBLIC = MethodHandles.publicLookup();
32.279 +
32.280 + // Subject methods...
32.281 + static class Example implements IntExample {
32.282 + final String name;
32.283 + public Example() { name = "Example#"+(nextArg++); }
32.284 + protected Example(String name) { this.name = name; }
32.285 + protected Example(int x) { this(); called("protected <init>", this, x); }
32.286 + @Override public String toString() { return name; }
32.287 +
32.288 + public void v0() { called("v0", this); }
32.289 + void pkg_v0() { called("pkg_v0", this); }
32.290 + private void pri_v0() { called("pri_v0", this); }
32.291 + public static void s0() { called("s0"); }
32.292 + static void pkg_s0() { called("pkg_s0"); }
32.293 + private static void pri_s0() { called("pri_s0"); }
32.294 +
32.295 + public Object v1(Object x) { return called("v1", this, x); }
32.296 + public Object v2(Object x, Object y) { return called("v2", this, x, y); }
32.297 + public Object v2(Object x, int y) { return called("v2", this, x, y); }
32.298 + public Object v2(int x, Object y) { return called("v2", this, x, y); }
32.299 + public Object v2(int x, int y) { return called("v2", this, x, y); }
32.300 + public static Object s1(Object x) { return called("s1", x); }
32.301 + public static Object s2(int x) { return called("s2", x); }
32.302 + public static Object s3(long x) { return called("s3", x); }
32.303 + public static Object s4(int x, int y) { return called("s4", x, y); }
32.304 + public static Object s5(long x, int y) { return called("s5", x, y); }
32.305 + public static Object s6(int x, long y) { return called("s6", x, y); }
32.306 + public static Object s7(float x, double y) { return called("s7", x, y); }
32.307 + }
32.308 + public static class PubExample extends Example {
32.309 + }
32.310 + static class SubExample extends Example {
32.311 + @Override public void v0() { called("Sub/v0", this); }
32.312 + @Override void pkg_v0() { called("Sub/pkg_v0", this); }
32.313 + private SubExample(int x) { called("<init>", this, x); }
32.314 + public SubExample() { super("SubExample#"+(nextArg++)); }
32.315 + }
32.316 + public static interface IntExample {
32.317 + public void v0();
32.318 + static class Impl implements IntExample {
32.319 + public void v0() { called("Int/v0", this); }
32.320 + final String name;
32.321 + public Impl() { name = "Example#"+(nextArg++); }
32.322 + }
32.323 + }
32.324 +
32.325 + static final Object[][][] ACCESS_CASES = {
32.326 + { { false, PUBLIC }, { false, PACKAGE }, { false, PRIVATE } },
32.327 + { { false, PUBLIC }, { false, PACKAGE }, { true, PRIVATE } },
32.328 + { { false, PUBLIC }, { true, PACKAGE }, { true, PRIVATE } },
32.329 + { { true, PUBLIC }, { true, PACKAGE }, { true, PRIVATE } },
32.330 + };
32.331 +
32.332 + static Object[][] accessCases(Class<?> defc, String name) {
32.333 + if (name.contains("pri_")) {
32.334 + return ACCESS_CASES[1]; // PRIVATE only
32.335 + } else if (name.contains("pkg_")) {
32.336 + return ACCESS_CASES[2]; // not PUBLIC
32.337 + } else {
32.338 + assertTrue(name.indexOf('_') < 0);
32.339 + boolean pubc = Modifier.isPublic(defc.getModifiers());
32.340 + if (pubc)
32.341 + return ACCESS_CASES[3]; // all access levels
32.342 + return ACCESS_CASES[2]; // PACKAGE but not PUBLIC
32.343 + }
32.344 + }
32.345 +
32.346 + @Test
32.347 + public void testFindStatic() throws Throwable {
32.348 + if (CAN_SKIP_WORKING) return;
32.349 + startTest("findStatic");
32.350 + testFindStatic(PubExample.class, void.class, "s0");
32.351 + testFindStatic(Example.class, void.class, "s0");
32.352 + testFindStatic(Example.class, void.class, "pkg_s0");
32.353 + testFindStatic(Example.class, void.class, "pri_s0");
32.354 +
32.355 + testFindStatic(Example.class, Object.class, "s1", Object.class);
32.356 + testFindStatic(Example.class, Object.class, "s2", int.class);
32.357 + testFindStatic(Example.class, Object.class, "s3", long.class);
32.358 + testFindStatic(Example.class, Object.class, "s4", int.class, int.class);
32.359 + testFindStatic(Example.class, Object.class, "s5", long.class, int.class);
32.360 + testFindStatic(Example.class, Object.class, "s6", int.class, long.class);
32.361 + testFindStatic(Example.class, Object.class, "s7", float.class, double.class);
32.362 +
32.363 + testFindStatic(false, PRIVATE, Example.class, void.class, "bogus");
32.364 + }
32.365 +
32.366 + void testFindStatic(Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.367 + for (Object[] ac : accessCases(defc, name)) {
32.368 + testFindStatic((Boolean)ac[0], (Lookup)ac[1], defc, ret, name, params);
32.369 + }
32.370 + }
32.371 + void testFindStatic(Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.372 + testFindStatic(true, lookup, defc, ret, name, params);
32.373 + }
32.374 + void testFindStatic(boolean positive, Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.375 + countTest(positive);
32.376 + MethodType type = MethodType.methodType(ret, params);
32.377 + MethodHandle target = null;
32.378 + RuntimeException noAccess = null;
32.379 + try {
32.380 + target = lookup.findStatic(defc, name, type);
32.381 + } catch (NoAccessException ex) {
32.382 + noAccess = ex;
32.383 + }
32.384 + if (verbosity >= 2)
32.385 + System.out.println("findStatic "+lookup+": "+defc+"."+name+"/"+type+" => "+target
32.386 + +(noAccess == null ? "" : " !! "+noAccess));
32.387 + if (positive && noAccess != null) throw noAccess;
32.388 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.389 + if (!positive) return; // negative test failed as expected
32.390 + assertEquals(type, target.type());
32.391 + assertTrue(target.toString().contains(name)); // rough check
32.392 + if (!DO_MORE_CALLS && lookup != PRIVATE) return;
32.393 + Object[] args = randomArgs(params);
32.394 + printCalled(target, name, args);
32.395 + target.invokeVarargs(args);
32.396 + assertCalled(name, args);
32.397 + System.out.print(':');
32.398 + }
32.399 +
32.400 + @Test
32.401 + public void testFindVirtual() throws Throwable {
32.402 + if (CAN_SKIP_WORKING) return;
32.403 + startTest("findVirtual");
32.404 + testFindVirtual(Example.class, void.class, "v0");
32.405 + testFindVirtual(Example.class, void.class, "pkg_v0");
32.406 + testFindVirtual(Example.class, void.class, "pri_v0");
32.407 + testFindVirtual(Example.class, Object.class, "v1", Object.class);
32.408 + testFindVirtual(Example.class, Object.class, "v2", Object.class, Object.class);
32.409 + testFindVirtual(Example.class, Object.class, "v2", Object.class, int.class);
32.410 + testFindVirtual(Example.class, Object.class, "v2", int.class, Object.class);
32.411 + testFindVirtual(Example.class, Object.class, "v2", int.class, int.class);
32.412 + testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "bogus");
32.413 + // test dispatch
32.414 + testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/v0");
32.415 + testFindVirtual(SubExample.class, Example.class, void.class, "Sub/v0");
32.416 + testFindVirtual(SubExample.class, IntExample.class, void.class, "Sub/v0");
32.417 + testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/pkg_v0");
32.418 + testFindVirtual(SubExample.class, Example.class, void.class, "Sub/pkg_v0");
32.419 + testFindVirtual(Example.class, IntExample.class, void.class, "v0");
32.420 + testFindVirtual(IntExample.Impl.class, IntExample.class, void.class, "Int/v0");
32.421 + }
32.422 +
32.423 + void testFindVirtual(Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.424 + Class<?> rcvc = defc;
32.425 + testFindVirtual(rcvc, defc, ret, name, params);
32.426 + }
32.427 + void testFindVirtual(Class<?> rcvc, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.428 + for (Object[] ac : accessCases(defc, name)) {
32.429 + testFindVirtual((Boolean)ac[0], (Lookup)ac[1], rcvc, defc, ret, name, params);
32.430 + }
32.431 + }
32.432 + void testFindVirtual(Lookup lookup, Class<?> rcvc, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.433 + testFindVirtual(true, lookup, rcvc, defc, ret, name, params);
32.434 + }
32.435 + void testFindVirtual(boolean positive, Lookup lookup, Class<?> rcvc, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.436 + countTest(positive);
32.437 + String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo
32.438 + MethodType type = MethodType.methodType(ret, params);
32.439 + MethodHandle target = null;
32.440 + RuntimeException noAccess = null;
32.441 + try {
32.442 + target = lookup.findVirtual(defc, methodName, type);
32.443 + } catch (NoAccessException ex) {
32.444 + noAccess = ex;
32.445 + }
32.446 + if (verbosity >= 2)
32.447 + System.out.println("findVirtual "+lookup+": "+defc+"."+name+"/"+type+" => "+target
32.448 + +(noAccess == null ? "" : " !! "+noAccess));
32.449 + if (positive && noAccess != null) throw noAccess;
32.450 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.451 + if (!positive) return; // negative test failed as expected
32.452 + Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);
32.453 + MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
32.454 + MethodType ttype = target.type();
32.455 + ttype = ttype.changeParameterType(0, defc); // FIXME: test this
32.456 + assertEquals(typeWithSelf, ttype);
32.457 + assertTrue(target.toString().contains(methodName)); // rough check
32.458 + if (!DO_MORE_CALLS && lookup != PRIVATE) return;
32.459 + Object[] argsWithSelf = randomArgs(paramsWithSelf);
32.460 + if (rcvc != defc) argsWithSelf[0] = randomArg(rcvc);
32.461 + printCalled(target, name, argsWithSelf);
32.462 + target.invokeVarargs(argsWithSelf);
32.463 + assertCalled(name, argsWithSelf);
32.464 + System.out.print(':');
32.465 + }
32.466 +
32.467 + @Test
32.468 + public void testFindSpecial() throws Throwable {
32.469 + if (CAN_SKIP_WORKING) return;
32.470 + startTest("findSpecial");
32.471 + testFindSpecial(Example.class, void.class, "v0");
32.472 + testFindSpecial(Example.class, void.class, "pkg_v0");
32.473 + testFindSpecial(false, PRIVATE, Example.class, void.class, "<init>", int.class);
32.474 + testFindSpecial(false, PRIVATE, Example.class, void.class, "bogus");
32.475 + }
32.476 +
32.477 + void testFindSpecial(Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.478 + testFindSpecial(true, PRIVATE, defc, ret, name, params);
32.479 + testFindSpecial(false, PACKAGE, defc, ret, name, params);
32.480 + testFindSpecial(false, PUBLIC, defc, ret, name, params);
32.481 + }
32.482 + void testFindSpecial(boolean positive, Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.483 + countTest(positive);
32.484 + MethodType type = MethodType.methodType(ret, params);
32.485 + MethodHandle target = null;
32.486 + RuntimeException noAccess = null;
32.487 + try {
32.488 + target = lookup.findSpecial(defc, name, type, defc);
32.489 + } catch (NoAccessException ex) {
32.490 + noAccess = ex;
32.491 + }
32.492 + if (verbosity >= 2)
32.493 + System.out.println("findSpecial "+defc+"."+name+"/"+type+" => "+target
32.494 + +(noAccess == null ? "" : " !! "+noAccess));
32.495 + if (positive && noAccess != null) throw noAccess;
32.496 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.497 + if (!positive) return; // negative test failed as expected
32.498 + Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);
32.499 + MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
32.500 + MethodType ttype = target.type();
32.501 + ttype = ttype.changeParameterType(0, defc); // FIXME: test this
32.502 + assertEquals(typeWithSelf, ttype);
32.503 + assertTrue(target.toString().contains(name)); // rough check
32.504 + if (!DO_MORE_CALLS && lookup != PRIVATE) return;
32.505 + Object[] args = randomArgs(paramsWithSelf);
32.506 + printCalled(target, name, args);
32.507 + target.invokeVarargs(args);
32.508 + assertCalled(name, args);
32.509 + System.out.print(':');
32.510 + }
32.511 +
32.512 + @Test
32.513 + public void testBind() throws Throwable {
32.514 + if (CAN_SKIP_WORKING) return;
32.515 + startTest("bind");
32.516 + testBind(Example.class, void.class, "v0");
32.517 + testBind(Example.class, void.class, "pkg_v0");
32.518 + testBind(Example.class, void.class, "pri_v0");
32.519 + testBind(Example.class, Object.class, "v1", Object.class);
32.520 + testBind(Example.class, Object.class, "v2", Object.class, Object.class);
32.521 + testBind(Example.class, Object.class, "v2", Object.class, int.class);
32.522 + testBind(Example.class, Object.class, "v2", int.class, Object.class);
32.523 + testBind(Example.class, Object.class, "v2", int.class, int.class);
32.524 + testBind(false, PRIVATE, Example.class, void.class, "bogus");
32.525 + testBind(SubExample.class, void.class, "Sub/v0");
32.526 + testBind(SubExample.class, void.class, "Sub/pkg_v0");
32.527 + testBind(IntExample.Impl.class, void.class, "Int/v0");
32.528 + }
32.529 +
32.530 + void testBind(Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.531 + for (Object[] ac : accessCases(defc, name)) {
32.532 + testBind((Boolean)ac[0], (Lookup)ac[1], defc, ret, name, params);
32.533 + }
32.534 + }
32.535 +
32.536 + void testBind(boolean positive, Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.537 + countTest(positive);
32.538 + String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo
32.539 + MethodType type = MethodType.methodType(ret, params);
32.540 + Object receiver = randomArg(defc);
32.541 + MethodHandle target = null;
32.542 + RuntimeException noAccess = null;
32.543 + try {
32.544 + target = lookup.bind(receiver, methodName, type);
32.545 + } catch (NoAccessException ex) {
32.546 + noAccess = ex;
32.547 + }
32.548 + if (verbosity >= 2)
32.549 + System.out.println("bind "+receiver+"."+name+"/"+type+" => "+target
32.550 + +(noAccess == null ? "" : " !! "+noAccess));
32.551 + if (positive && noAccess != null) throw noAccess;
32.552 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.553 + if (!positive) return; // negative test failed as expected
32.554 + assertEquals(type, target.type());
32.555 + Object[] args = randomArgs(params);
32.556 + printCalled(target, name, args);
32.557 + target.invokeVarargs(args);
32.558 + Object[] argsWithReceiver = cat(array(Object[].class, receiver), args);
32.559 + assertCalled(name, argsWithReceiver);
32.560 + System.out.print(':');
32.561 + }
32.562 +
32.563 + @Test
32.564 + public void testUnreflect() throws Throwable {
32.565 + if (CAN_SKIP_WORKING) return;
32.566 + startTest("unreflect");
32.567 + testUnreflect(Example.class, true, void.class, "s0");
32.568 + testUnreflect(Example.class, true, void.class, "pkg_s0");
32.569 + testUnreflect(Example.class, true, void.class, "pri_s0");
32.570 +
32.571 + testUnreflect(Example.class, true, Object.class, "s1", Object.class);
32.572 + testUnreflect(Example.class, true, Object.class, "s2", int.class);
32.573 + //testUnreflect(Example.class, true, Object.class, "s3", long.class);
32.574 + //testUnreflect(Example.class, true, Object.class, "s4", int.class, int.class);
32.575 + //testUnreflect(Example.class, true, Object.class, "s5", long.class, int.class);
32.576 + //testUnreflect(Example.class, true, Object.class, "s6", int.class, long.class);
32.577 +
32.578 + testUnreflect(Example.class, false, void.class, "v0");
32.579 + testUnreflect(Example.class, false, void.class, "pkg_v0");
32.580 + testUnreflect(Example.class, false, void.class, "pri_v0");
32.581 + testUnreflect(Example.class, false, Object.class, "v1", Object.class);
32.582 + testUnreflect(Example.class, false, Object.class, "v2", Object.class, Object.class);
32.583 + testUnreflect(Example.class, false, Object.class, "v2", Object.class, int.class);
32.584 + testUnreflect(Example.class, false, Object.class, "v2", int.class, Object.class);
32.585 + testUnreflect(Example.class, false, Object.class, "v2", int.class, int.class);
32.586 + }
32.587 +
32.588 + void testUnreflect(Class<?> defc, boolean isStatic, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.589 + for (Object[] ac : accessCases(defc, name)) {
32.590 + testUnreflect((Boolean)ac[0], (Lookup)ac[1], defc, isStatic, ret, name, params);
32.591 + }
32.592 + }
32.593 + void testUnreflect(boolean positive, Lookup lookup, Class<?> defc, boolean isStatic, Class<?> ret, String name, Class<?>... params) throws Throwable {
32.594 + countTest(positive);
32.595 + MethodType type = MethodType.methodType(ret, params);
32.596 + Method rmethod = null;
32.597 + MethodHandle target = null;
32.598 + RuntimeException noAccess = null;
32.599 + try {
32.600 + rmethod = defc.getDeclaredMethod(name, params);
32.601 + } catch (NoSuchMethodException ex) {
32.602 + throw new NoAccessException(ex);
32.603 + }
32.604 + assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
32.605 + try {
32.606 + target = lookup.unreflect(rmethod);
32.607 + } catch (NoAccessException ex) {
32.608 + noAccess = ex;
32.609 + }
32.610 + if (verbosity >= 2)
32.611 + System.out.println("unreflect "+defc+"."+name+"/"+type+" => "+target
32.612 + +(noAccess == null ? "" : " !! "+noAccess));
32.613 + if (positive && noAccess != null) throw noAccess;
32.614 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.615 + if (!positive) return; // negative test failed as expected
32.616 + Class<?>[] paramsMaybeWithSelf = params;
32.617 + if (!isStatic) {
32.618 + paramsMaybeWithSelf = cat(array(Class[].class, (Class)defc), params);
32.619 + }
32.620 + MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
32.621 + MethodType ttype = target.type();
32.622 + if (!isStatic)
32.623 + ttype = ttype.changeParameterType(0, defc); // FIXME: test this
32.624 + assertEquals(typeMaybeWithSelf, ttype);
32.625 + Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
32.626 + printCalled(target, name, argsMaybeWithSelf);
32.627 + target.invokeVarargs(argsMaybeWithSelf);
32.628 + assertCalled(name, argsMaybeWithSelf);
32.629 + System.out.print(':');
32.630 + }
32.631 +
32.632 + @Test @Ignore("unimplemented")
32.633 + public void testUnreflectSpecial() throws Throwable {
32.634 + Lookup lookup = PRIVATE; // FIXME: test more lookups than this one
32.635 + startTest("unreflectSpecial");
32.636 + Method m = null;
32.637 + MethodHandle expResult = null;
32.638 + MethodHandle result = lookup.unreflectSpecial(m, Example.class);
32.639 + assertEquals(expResult, result);
32.640 + fail("The test case is a prototype.");
32.641 + }
32.642 +
32.643 + public static class HasFields {
32.644 + boolean fZ = false;
32.645 + byte fB = (byte)'B';
32.646 + short fS = (short)'S';
32.647 + char fC = 'C';
32.648 + int fI = 'I';
32.649 + long fJ = 'J';
32.650 + float fF = 'F';
32.651 + double fD = 'D';
32.652 + static boolean sZ = true;
32.653 + static byte sB = 1+(byte)'B';
32.654 + static short sS = 1+(short)'S';
32.655 + static char sC = 1+'C';
32.656 + static int sI = 1+'I';
32.657 + static long sJ = 1+'J';
32.658 + static float sF = 1+'F';
32.659 + static double sD = 1+'D';
32.660 +
32.661 + Object fL = 'L';
32.662 + String fR = "R";
32.663 + static Object sL = 'M';
32.664 + static String sR = "S";
32.665 +
32.666 + static final Object[][] CASES;
32.667 + static {
32.668 + ArrayList<Object[]> cases = new ArrayList<Object[]>();
32.669 + Object types[][] = {
32.670 + {'L',Object.class}, {'R',String.class},
32.671 + {'I',int.class}, {'J',long.class},
32.672 + {'F',float.class}, {'D',double.class},
32.673 + {'Z',boolean.class}, {'B',byte.class},
32.674 + {'S',short.class}, {'C',char.class},
32.675 + };
32.676 + HasFields fields = new HasFields();
32.677 + for (Object[] t : types) {
32.678 + for (int kind = 0; kind <= 1; kind++) {
32.679 + boolean isStatic = (kind != 0);
32.680 + char btc = (Character)t[0];
32.681 + String name = (isStatic ? "s" : "f") + btc;
32.682 + Class<?> type = (Class<?>) t[1];
32.683 + Object value;
32.684 + Field field;
32.685 + try {
32.686 + field = HasFields.class.getDeclaredField(name);
32.687 + } catch (Exception ex) {
32.688 + throw new InternalError("no field HasFields."+name);
32.689 + }
32.690 + try {
32.691 + value = field.get(fields);
32.692 + } catch (Exception ex) {
32.693 + throw new InternalError("cannot fetch field HasFields."+name);
32.694 + }
32.695 + if (type == float.class) {
32.696 + float v = 'F';
32.697 + if (isStatic) v++;
32.698 + assert(value.equals(v));
32.699 + }
32.700 + assert(name.equals(field.getName()));
32.701 + assert(type.equals(field.getType()));
32.702 + assert(isStatic == (Modifier.isStatic(field.getModifiers())));
32.703 + cases.add(new Object[]{ field, value });
32.704 + }
32.705 + }
32.706 + CASES = cases.toArray(new Object[0][]);
32.707 + }
32.708 + }
32.709 +
32.710 + @Test
32.711 + public void testUnreflectGetter() throws Throwable {
32.712 + Lookup lookup = PRIVATE; // FIXME: test more lookups than this one
32.713 + startTest("unreflectGetter");
32.714 + for (Object[] c : HasFields.CASES) {
32.715 + Field f = (Field)c[0];
32.716 + Object value = c[1];
32.717 + Class<?> type = f.getType();
32.718 + if (type.isPrimitive() && type != int.class)
32.719 + continue; //FIXME
32.720 + testUnreflectGetter(lookup, f, type, value);
32.721 + }
32.722 + }
32.723 + public void testUnreflectGetter(MethodHandles.Lookup lookup,
32.724 + Field f, Class<?> type, Object value) throws Throwable {
32.725 + countTest(true);
32.726 + boolean isStatic = Modifier.isStatic(f.getModifiers());
32.727 + MethodType expType = MethodType.methodType(type, HasFields.class);
32.728 + if (isStatic) expType = expType.dropParameterTypes(0, 1);
32.729 + MethodHandle mh = lookup.unreflectGetter(f);
32.730 + assertSame(mh.type(), expType);
32.731 + assertEquals(mh.toString(), f.getName());
32.732 + HasFields fields = new HasFields();
32.733 + Object sawValue;
32.734 + Class<?> rtype = type;
32.735 + if (type != int.class) rtype = Object.class;
32.736 + mh = MethodHandles.convertArguments(mh, mh.type().generic().changeReturnType(rtype));
32.737 + Object expValue = value;
32.738 + for (int i = 0; i <= 1; i++) {
32.739 + if (isStatic) {
32.740 + if (type == int.class)
32.741 + sawValue = mh.<int>invoke(); // do these exactly
32.742 + else
32.743 + sawValue = mh.invoke();
32.744 + } else {
32.745 + if (type == int.class)
32.746 + sawValue = mh.<int>invoke((Object) fields);
32.747 + else
32.748 + sawValue = mh.invoke((Object) fields);
32.749 + }
32.750 + assertEquals(sawValue, expValue);
32.751 + Object random = randomArg(type);
32.752 + f.set(fields, random);
32.753 + expValue = random;
32.754 + }
32.755 + f.set(fields, value); // put it back
32.756 + }
32.757 +
32.758 +
32.759 + @Test
32.760 + public void testUnreflectSetter() throws Throwable {
32.761 + Lookup lookup = PRIVATE; // FIXME: test more lookups than this one
32.762 + startTest("unreflectSetter");
32.763 + for (Object[] c : HasFields.CASES) {
32.764 + Field f = (Field)c[0];
32.765 + Object value = c[1];
32.766 + Class<?> type = f.getType();
32.767 + if (type.isPrimitive() && type != int.class)
32.768 + continue; //FIXME
32.769 + testUnreflectSetter(lookup, f, type, value);
32.770 + }
32.771 + }
32.772 + public void testUnreflectSetter(MethodHandles.Lookup lookup,
32.773 + Field f, Class<?> type, Object value) throws Throwable {
32.774 + countTest(true);
32.775 + boolean isStatic = Modifier.isStatic(f.getModifiers());
32.776 + MethodType expType = MethodType.methodType(void.class, HasFields.class, type);
32.777 + if (isStatic) expType = expType.dropParameterTypes(0, 1);
32.778 + MethodHandle mh = lookup.unreflectSetter(f);
32.779 + assertSame(mh.type(), expType);
32.780 + assertEquals(mh.toString(), f.getName());
32.781 + HasFields fields = new HasFields();
32.782 + Object sawValue;
32.783 + Class<?> vtype = type;
32.784 + if (type != int.class) vtype = Object.class;
32.785 + int last = mh.type().parameterCount() - 1;
32.786 + mh = MethodHandles.convertArguments(mh, mh.type().generic().changeReturnType(void.class).changeParameterType(last, vtype));
32.787 + assertEquals(f.get(fields), value); // clean to start with
32.788 + for (int i = 0; i <= 1; i++) {
32.789 + Object putValue = randomArg(type);
32.790 + if (isStatic) {
32.791 + if (type == int.class)
32.792 + mh.<void>invoke((int)(Integer)putValue); // do these exactly
32.793 + else
32.794 + mh.<void>invoke(putValue);
32.795 + } else {
32.796 + if (type == int.class)
32.797 + mh.<void>invoke((Object) fields, (int)(Integer)putValue);
32.798 + else
32.799 + mh.<void>invoke((Object) fields, putValue);
32.800 + }
32.801 + assertEquals(f.get(fields), putValue);
32.802 + }
32.803 + f.set(fields, value); // put it back
32.804 + }
32.805 +
32.806 + @Test
32.807 + public void testArrayElementGetter() throws Throwable {
32.808 + startTest("arrayElementGetter");
32.809 + testArrayElementGetterSetter(new Object[10], false);
32.810 + testArrayElementGetterSetter(new String[10], false);
32.811 + testArrayElementGetterSetter(new int[10], false);
32.812 + // FIXME: Do the other primitive types.
32.813 + //testArrayElementGetterSetter(new float[10], false);
32.814 + }
32.815 +
32.816 + @Test
32.817 + public void testArrayElementSetter() throws Throwable {
32.818 + startTest("arrayElementSetter");
32.819 + testArrayElementGetterSetter(new Object[10], true);
32.820 + testArrayElementGetterSetter(new String[10], true);
32.821 + testArrayElementGetterSetter(new int[10], true);
32.822 + // FIXME: Do the other primitive types.
32.823 + //testArrayElementGetterSetter(new float[10], true);
32.824 + }
32.825 +
32.826 + public void testArrayElementGetterSetter(Object array, boolean testSetter) throws Throwable {
32.827 + countTest(true);
32.828 + Class<?> arrayType = array.getClass();
32.829 + Class<?> elemType = arrayType.getComponentType();
32.830 + MethodType expType = !testSetter
32.831 + ? MethodType.methodType(elemType, arrayType, int.class)
32.832 + : MethodType.methodType(void.class, arrayType, int.class, elemType);
32.833 + MethodHandle mh = !testSetter
32.834 + ? MethodHandles.arrayElementGetter(arrayType)
32.835 + : MethodHandles.arrayElementSetter(arrayType);
32.836 + assertSame(mh.type(), expType);
32.837 + //assertEquals(mh.toString(), f.getName());
32.838 + Object sawValue, expValue;
32.839 + List<Object> model = array2list(array);
32.840 + int length = Array.getLength(array);
32.841 + for (int i = 0; i < length; i++) {
32.842 + // update array element
32.843 + Object random = randomArg(elemType);
32.844 + model.set(i, random);
32.845 + if (testSetter) {
32.846 + if (elemType == int.class)
32.847 + mh.<void>invoke((int[]) array, i, (int)(Integer)random);
32.848 + else
32.849 + mh.invokeGeneric(array, i, random);
32.850 + assertEquals(model, array2list(array));
32.851 + } else {
32.852 + Array.set(array, i, random);
32.853 +
32.854 + }
32.855 + // observe array element
32.856 + sawValue = Array.get(array, i);
32.857 + if (!testSetter) {
32.858 + expValue = sawValue;
32.859 + if (elemType == int.class)
32.860 + sawValue = mh.<int>invoke((int[]) array, i);
32.861 + else
32.862 + sawValue = mh.invokeGeneric(array, i);
32.863 + assertEquals(sawValue, expValue);
32.864 + assertEquals(model, array2list(array));
32.865 + }
32.866 + }
32.867 + }
32.868 +
32.869 + List<Object> array2list(Object array) {
32.870 + int length = Array.getLength(array);
32.871 + ArrayList<Object> model = new ArrayList<Object>(length);
32.872 + for (int i = 0; i < length; i++)
32.873 + model.add(Array.get(array, i));
32.874 + return model;
32.875 + }
32.876 +
32.877 + static class Callee {
32.878 + static Object id() { return called("id"); }
32.879 + static Object id(Object x) { return called("id", x); }
32.880 + static Object id(Object x, Object y) { return called("id", x, y); }
32.881 + static Object id(Object x, Object y, Object z) { return called("id", x, y, z); }
32.882 + static Object id(Object... vx) { return called("id", vx); }
32.883 + static MethodHandle ofType(int n) {
32.884 + return ofType(Object.class, n);
32.885 + }
32.886 + static MethodHandle ofType(Class<?> rtype, int n) {
32.887 + if (n == -1)
32.888 + return ofType(MethodType.methodType(rtype, Object[].class));
32.889 + return ofType(MethodType.genericMethodType(n).changeReturnType(rtype));
32.890 + }
32.891 + static MethodHandle ofType(Class<?> rtype, Class<?>... ptypes) {
32.892 + return ofType(MethodType.methodType(rtype, ptypes));
32.893 + }
32.894 + static MethodHandle ofType(MethodType type) {
32.895 + Class<?> rtype = type.returnType();
32.896 + String pfx = "";
32.897 + if (rtype != Object.class)
32.898 + pfx = rtype.getSimpleName().substring(0, 1).toLowerCase();
32.899 + String name = pfx+"id";
32.900 + return PRIVATE.findStatic(Callee.class, name, type);
32.901 + }
32.902 + }
32.903 +
32.904 + @Test
32.905 + public void testConvertArguments() throws Throwable {
32.906 + if (CAN_SKIP_WORKING) return;
32.907 + startTest("convertArguments");
32.908 + testConvert(Callee.ofType(1), null, "id", int.class);
32.909 + testConvert(Callee.ofType(1), null, "id", String.class);
32.910 + testConvert(Callee.ofType(1), null, "id", Integer.class);
32.911 + testConvert(Callee.ofType(1), null, "id", short.class);
32.912 + }
32.913 +
32.914 + void testConvert(MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {
32.915 + testConvert(true, id, rtype, name, params);
32.916 + }
32.917 +
32.918 + void testConvert(boolean positive, MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {
32.919 + countTest(positive);
32.920 + MethodType idType = id.type();
32.921 + if (rtype == null) rtype = idType.returnType();
32.922 + for (int i = 0; i < params.length; i++) {
32.923 + if (params[i] == null) params[i] = idType.parameterType(i);
32.924 + }
32.925 + // simulate the pairwise conversion
32.926 + MethodType newType = MethodType.methodType(rtype, params);
32.927 + Object[] args = randomArgs(newType.parameterArray());
32.928 + Object[] convArgs = args.clone();
32.929 + for (int i = 0; i < args.length; i++) {
32.930 + Class<?> src = newType.parameterType(i);
32.931 + Class<?> dst = idType.parameterType(i);
32.932 + if (src != dst)
32.933 + convArgs[i] = castToWrapper(convArgs[i], dst);
32.934 + }
32.935 + Object convResult = id.invokeVarargs(convArgs);
32.936 + {
32.937 + Class<?> dst = newType.returnType();
32.938 + Class<?> src = idType.returnType();
32.939 + if (src != dst)
32.940 + convResult = castToWrapper(convResult, dst);
32.941 + }
32.942 + MethodHandle target = null;
32.943 + RuntimeException error = null;
32.944 + try {
32.945 + target = MethodHandles.convertArguments(id, newType);
32.946 + } catch (RuntimeException ex) {
32.947 + error = ex;
32.948 + }
32.949 + if (verbosity >= 2)
32.950 + System.out.println("convert "+id+ " to "+newType+" => "+target
32.951 + +(error == null ? "" : " !! "+error));
32.952 + if (positive && error != null) throw error;
32.953 + assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
32.954 + if (!positive) return; // negative test failed as expected
32.955 + assertEquals(newType, target.type());
32.956 + printCalled(target, id.toString(), args);
32.957 + Object result = target.invokeVarargs(args);
32.958 + assertCalled(name, convArgs);
32.959 + assertEquals(convResult, result);
32.960 + System.out.print(':');
32.961 + }
32.962 +
32.963 + @Test
32.964 + public void testPermuteArguments() throws Throwable {
32.965 + if (CAN_SKIP_WORKING) return;
32.966 + startTest("permuteArguments");
32.967 + testPermuteArguments(4, Integer.class, 2, String.class, 0);
32.968 + //testPermuteArguments(6, Integer.class, 0, null, 30);
32.969 + //testPermuteArguments(4, Integer.class, 1, int.class, 6);
32.970 + }
32.971 + public void testPermuteArguments(int max, Class<?> type1, int t2c, Class<?> type2, int dilution) throws Throwable {
32.972 + if (verbosity >= 1)
32.973 + System.out.println("permuteArguments "+max+"*"+type1.getName()
32.974 + +(t2c==0?"":"/"+t2c+"*"+type2.getName())
32.975 + +(dilution > 0 ? " with dilution "+dilution : ""));
32.976 + int t2pos = t2c == 0 ? 0 : 1;
32.977 + for (int inargs = t2pos+1; inargs <= max; inargs++) {
32.978 + Class<?>[] types = new Class<?>[inargs];
32.979 + Arrays.fill(types, type1);
32.980 + if (t2c != 0) {
32.981 + // Fill in a middle range with type2:
32.982 + Arrays.fill(types, t2pos, Math.min(t2pos+t2c, inargs), type2);
32.983 + }
32.984 + Object[] args = randomArgs(types);
32.985 + int numcases = 1;
32.986 + for (int outargs = 0; outargs <= max; outargs++) {
32.987 + if (outargs - inargs >= MAX_ARG_INCREASE) continue;
32.988 + int[] reorder = new int[outargs];
32.989 + int casStep = dilution + 1;
32.990 + // Avoid some common factors:
32.991 + while ((casStep > 2 && casStep % 2 == 0 && inargs % 2 == 0) ||
32.992 + (casStep > 3 && casStep % 3 == 0 && inargs % 3 == 0))
32.993 + casStep++;
32.994 + for (int cas = 0; cas < numcases; cas += casStep) {
32.995 + for (int i = 0, c = cas; i < outargs; i++) {
32.996 + reorder[i] = c % inargs;
32.997 + c /= inargs;
32.998 + }
32.999 + testPermuteArguments(args, types, reorder);
32.1000 + }
32.1001 + numcases *= inargs;
32.1002 + if (dilution > 10 && outargs >= 4) {
32.1003 + // Do some special patterns, which we probably missed.
32.1004 + // Replication of a single argument or argument pair.
32.1005 + for (int i = 0; i < inargs; i++) {
32.1006 + Arrays.fill(reorder, i);
32.1007 + testPermuteArguments(args, types, reorder);
32.1008 + for (int d = 1; d <= 2; d++) {
32.1009 + if (i + d >= inargs) continue;
32.1010 + for (int j = 1; j < outargs; j += 2)
32.1011 + reorder[j] += 1;
32.1012 + testPermuteArguments(args, types, reorder);
32.1013 + testPermuteArguments(args, types, reverse(reorder));
32.1014 + }
32.1015 + }
32.1016 + // Repetition of a sequence of 3 or more arguments.
32.1017 + for (int i = 1; i < inargs; i++) {
32.1018 + for (int len = 3; len <= inargs; len++) {
32.1019 + for (int j = 0; j < outargs; j++)
32.1020 + reorder[j] = (i + (j % len)) % inargs;
32.1021 + testPermuteArguments(args, types, reorder);
32.1022 + testPermuteArguments(args, types, reverse(reorder));
32.1023 + }
32.1024 + }
32.1025 + }
32.1026 + }
32.1027 + }
32.1028 + }
32.1029 +
32.1030 + static int[] reverse(int[] reorder) {
32.1031 + reorder = reorder.clone();
32.1032 + for (int i = 0, imax = reorder.length / 2; i < imax; i++) {
32.1033 + int j = reorder.length - 1 - i;
32.1034 + int tem = reorder[i];
32.1035 + reorder[i] = reorder[j];
32.1036 + reorder[j] = tem;
32.1037 + }
32.1038 + return reorder;
32.1039 + }
32.1040 +
32.1041 + void testPermuteArguments(Object[] args, Class<?>[] types, int[] reorder) throws Throwable {
32.1042 + countTest();
32.1043 + if (args == null && types == null) {
32.1044 + int max = 0;
32.1045 + for (int j : reorder) {
32.1046 + if (max < j) max = j;
32.1047 + }
32.1048 + args = randomArgs(max+1, Integer.class);
32.1049 + }
32.1050 + if (args == null) {
32.1051 + args = randomArgs(types);
32.1052 + }
32.1053 + if (types == null) {
32.1054 + types = new Class<?>[args.length];
32.1055 + for (int i = 0; i < args.length; i++)
32.1056 + types[i] = args[i].getClass();
32.1057 + }
32.1058 + int inargs = args.length, outargs = reorder.length;
32.1059 + assert(inargs == types.length);
32.1060 + if (verbosity >= 2)
32.1061 + System.out.println("permuteArguments "+Arrays.toString(reorder));
32.1062 + Object[] permArgs = new Object[outargs];
32.1063 + Class<?>[] permTypes = new Class<?>[outargs];
32.1064 + for (int i = 0; i < outargs; i++) {
32.1065 + permArgs[i] = args[reorder[i]];
32.1066 + permTypes[i] = types[reorder[i]];
32.1067 + }
32.1068 + if (verbosity >= 3) {
32.1069 + System.out.println("in args: "+Arrays.asList(args));
32.1070 + System.out.println("out args: "+Arrays.asList(permArgs));
32.1071 + System.out.println("in types: "+Arrays.asList(types));
32.1072 + System.out.println("out types: "+Arrays.asList(permTypes));
32.1073 + }
32.1074 + MethodType inType = MethodType.methodType(Object.class, types);
32.1075 + MethodType outType = MethodType.methodType(Object.class, permTypes);
32.1076 + MethodHandle target = MethodHandles.convertArguments(ValueConversions.varargsList(outargs), outType);
32.1077 + MethodHandle newTarget = MethodHandles.permuteArguments(target, inType, reorder);
32.1078 + Object result = newTarget.invokeVarargs(args);
32.1079 + Object expected = Arrays.asList(permArgs);
32.1080 + assertEquals(expected, result);
32.1081 + }
32.1082 +
32.1083 +
32.1084 + @Test
32.1085 + public void testSpreadArguments() throws Throwable {
32.1086 + if (CAN_SKIP_WORKING) return;
32.1087 + startTest("spreadArguments");
32.1088 + for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {
32.1089 + if (verbosity >= 2)
32.1090 + System.out.println("spreadArguments "+argType);
32.1091 + for (int nargs = 0; nargs < 10; nargs++) {
32.1092 + if (argType == int.class && nargs >= 6) continue; // FIXME Fail_1
32.1093 + for (int pos = 0; pos < nargs; pos++) {
32.1094 + if (argType == int.class && pos > 0) continue; // FIXME Fail_3
32.1095 + testSpreadArguments(argType, pos, nargs);
32.1096 + }
32.1097 + }
32.1098 + }
32.1099 + }
32.1100 + public void testSpreadArguments(Class<?> argType, int pos, int nargs) throws Throwable {
32.1101 + countTest();
32.1102 + MethodHandle target = ValueConversions.varargsArray(nargs);
32.1103 + MethodHandle target2 = changeArgTypes(target, argType);
32.1104 + if (verbosity >= 2)
32.1105 + System.out.println("spread into "+target2+" ["+pos+".."+nargs+"]");
32.1106 + Object[] args = randomArgs(target2.type().parameterArray());
32.1107 + // make sure the target does what we think it does:
32.1108 + if (pos == 0 && nargs < 5) {
32.1109 + Object[] check = (Object[]) target.invokeVarargs(args);
32.1110 + assertArrayEquals(args, check);
32.1111 + switch (nargs) {
32.1112 + case 0:
32.1113 + check = target.<Object[]>invoke();
32.1114 + assertArrayEquals(args, check);
32.1115 + break;
32.1116 + case 1:
32.1117 + check = target.<Object[]>invoke(args[0]);
32.1118 + assertArrayEquals(args, check);
32.1119 + break;
32.1120 + case 2:
32.1121 + check = target.<Object[]>invoke(args[0], args[1]);
32.1122 + assertArrayEquals(args, check);
32.1123 + break;
32.1124 + }
32.1125 + }
32.1126 + List<Class<?>> newParams = new ArrayList<Class<?>>(target2.type().parameterList());
32.1127 + { // modify newParams in place
32.1128 + List<Class<?>> spreadParams = newParams.subList(pos, nargs);
32.1129 + spreadParams.clear(); spreadParams.add(Object[].class);
32.1130 + }
32.1131 + MethodType newType = MethodType.methodType(Object.class, newParams);
32.1132 + MethodHandle result = MethodHandles.spreadArguments(target2, newType);
32.1133 + Object[] returnValue;
32.1134 + if (pos == 0) {
32.1135 + returnValue = (Object[]) result.invoke(args);
32.1136 + } else {
32.1137 + Object[] args1 = Arrays.copyOfRange(args, 0, pos+1);
32.1138 + args1[pos] = Arrays.copyOfRange(args, pos, args.length);
32.1139 + returnValue = (Object[]) result.invokeVarargs(args1);
32.1140 + }
32.1141 + assertArrayEquals(args, returnValue);
32.1142 + }
32.1143 +
32.1144 + @Test
32.1145 + public void testCollectArguments() throws Throwable {
32.1146 + if (CAN_SKIP_WORKING) return;
32.1147 + startTest("collectArguments");
32.1148 + for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {
32.1149 + if (verbosity >= 2)
32.1150 + System.out.println("collectArguments "+argType);
32.1151 + for (int nargs = 0; nargs < 10; nargs++) {
32.1152 + for (int pos = 0; pos < nargs; pos++) {
32.1153 + if (argType == int.class) continue; // FIXME Fail_4
32.1154 + testCollectArguments(argType, pos, nargs);
32.1155 + }
32.1156 + }
32.1157 + }
32.1158 + }
32.1159 + public void testCollectArguments(Class<?> argType, int pos, int nargs) throws Throwable {
32.1160 + countTest();
32.1161 + // fake up a MH with the same type as the desired adapter:
32.1162 + MethodHandle fake = ValueConversions.varargsArray(nargs);
32.1163 + fake = changeArgTypes(fake, argType);
32.1164 + MethodType newType = fake.type();
32.1165 + Object[] args = randomArgs(newType.parameterArray());
32.1166 + // here is what should happen:
32.1167 + Object[] collectedArgs = Arrays.copyOfRange(args, 0, pos+1);
32.1168 + collectedArgs[pos] = Arrays.copyOfRange(args, pos, args.length);
32.1169 + // here is the MH which will witness the collected argument tail:
32.1170 + MethodHandle target = ValueConversions.varargsArray(pos+1);
32.1171 + target = changeArgTypes(target, 0, pos, argType);
32.1172 + target = changeArgTypes(target, pos, pos+1, Object[].class);
32.1173 + if (verbosity >= 2)
32.1174 + System.out.println("collect from "+Arrays.asList(args)+" ["+pos+".."+nargs+"]");
32.1175 + MethodHandle result = MethodHandles.collectArguments(target, newType);
32.1176 + Object[] returnValue = (Object[]) result.invokeVarargs(args);
32.1177 +// assertTrue(returnValue.length == pos+1 && returnValue[pos] instanceof Object[]);
32.1178 +// returnValue[pos] = Arrays.asList((Object[]) returnValue[pos]);
32.1179 +// collectedArgs[pos] = Arrays.asList((Object[]) collectedArgs[pos]);
32.1180 + assertArrayEquals(collectedArgs, returnValue);
32.1181 + }
32.1182 +
32.1183 + @Test
32.1184 + public void testInsertArguments() throws Throwable {
32.1185 + if (CAN_SKIP_WORKING) return;
32.1186 + startTest("insertArguments");
32.1187 + for (int nargs = 0; nargs <= 4; nargs++) {
32.1188 + for (int ins = 0; ins <= 4; ins++) {
32.1189 + if (ins > MAX_ARG_INCREASE) continue; // FIXME Fail_6
32.1190 + for (int pos = 0; pos <= nargs; pos++) {
32.1191 + testInsertArguments(nargs, pos, ins);
32.1192 + }
32.1193 + }
32.1194 + }
32.1195 + }
32.1196 +
32.1197 + void testInsertArguments(int nargs, int pos, int ins) throws Throwable {
32.1198 + countTest();
32.1199 + MethodHandle target = ValueConversions.varargsArray(nargs + ins);
32.1200 + Object[] args = randomArgs(target.type().parameterArray());
32.1201 + List<Object> resList = Arrays.asList(args);
32.1202 + List<Object> argsToPass = new ArrayList<Object>(resList);
32.1203 + List<Object> argsToInsert = argsToPass.subList(pos, pos + ins);
32.1204 + if (verbosity >= 2)
32.1205 + System.out.println("insert: "+argsToInsert+" into "+target);
32.1206 + MethodHandle target2 = MethodHandles.insertArguments(target, pos,
32.1207 + (Object[]) argsToInsert.toArray());
32.1208 + argsToInsert.clear(); // remove from argsToInsert
32.1209 + Object res2 = target2.invokeVarargs(argsToPass);
32.1210 + Object res2List = Arrays.asList((Object[])res2);
32.1211 + if (verbosity >= 2)
32.1212 + System.out.println("result: "+res2List);
32.1213 + //if (!resList.equals(res2List))
32.1214 + // System.out.println("*** fail at n/p/i = "+nargs+"/"+pos+"/"+ins+": "+resList+" => "+res2List);
32.1215 + assertEquals(resList, res2List);
32.1216 + }
32.1217 +
32.1218 + @Test
32.1219 + public void testFilterArguments() throws Throwable {
32.1220 + if (CAN_SKIP_WORKING) return;
32.1221 + startTest("filterArguments");
32.1222 + for (int nargs = 1; nargs <= 6; nargs++) {
32.1223 + for (int pos = 0; pos < nargs; pos++) {
32.1224 + testFilterArguments(nargs, pos);
32.1225 + }
32.1226 + }
32.1227 + }
32.1228 +
32.1229 + void testFilterArguments(int nargs, int pos) throws Throwable {
32.1230 + countTest();
32.1231 + MethodHandle target = ValueConversions.varargsList(nargs);
32.1232 + MethodHandle filter = ValueConversions.varargsList(1);
32.1233 + filter = MethodHandles.convertArguments(filter, filter.type().generic());
32.1234 + Object[] argsToPass = randomArgs(nargs, Object.class);
32.1235 + if (verbosity >= 2)
32.1236 + System.out.println("filter "+target+" at "+pos+" with "+filter);
32.1237 + MethodHandle[] filters = new MethodHandle[pos*2+1];
32.1238 + filters[pos] = filter;
32.1239 + MethodHandle target2 = MethodHandles.filterArguments(target, filters);
32.1240 + // Simulate expected effect of filter on arglist:
32.1241 + Object[] filteredArgs = argsToPass.clone();
32.1242 + filteredArgs[pos] = filter.invoke(filteredArgs[pos]);
32.1243 + List<Object> expected = Arrays.asList(filteredArgs);
32.1244 + Object result = target2.invokeVarargs(argsToPass);
32.1245 + if (verbosity >= 2)
32.1246 + System.out.println("result: "+result);
32.1247 + if (!expected.equals(result))
32.1248 + System.out.println("*** fail at n/p = "+nargs+"/"+pos+": "+argsToPass+" => "+result);
32.1249 + assertEquals(expected, result);
32.1250 + }
32.1251 +
32.1252 + @Test
32.1253 + public void testFoldArguments() throws Throwable {
32.1254 + if (CAN_SKIP_WORKING) return;
32.1255 + startTest("foldArguments");
32.1256 + for (int nargs = 0; nargs <= 4; nargs++) {
32.1257 + for (int fold = 0; fold <= nargs; fold++) {
32.1258 + for (int pos = 0; pos <= nargs; pos++) {
32.1259 + testFoldArguments(nargs, pos, fold);
32.1260 + }
32.1261 + }
32.1262 + }
32.1263 + }
32.1264 +
32.1265 + void testFoldArguments(int nargs, int pos, int fold) throws Throwable {
32.1266 + if (pos != 0) return; // can fold only at pos=0 for now
32.1267 + countTest();
32.1268 + MethodHandle target = ValueConversions.varargsList(1 + nargs);
32.1269 + MethodHandle combine = ValueConversions.varargsList(fold);
32.1270 + List<Object> argsToPass = Arrays.asList(randomArgs(nargs, Object.class));
32.1271 + if (verbosity >= 2)
32.1272 + System.out.println("fold "+target+" with "+combine);
32.1273 + MethodHandle target2 = MethodHandles.foldArguments(target, combine);
32.1274 + // Simulate expected effect of combiner on arglist:
32.1275 + List<Object> expected = new ArrayList<Object>(argsToPass);
32.1276 + List<Object> argsToFold = expected.subList(pos, pos + fold);
32.1277 + if (verbosity >= 2)
32.1278 + System.out.println("fold: "+argsToFold+" into "+target2);
32.1279 + Object foldedArgs = combine.invokeVarargs(argsToFold);
32.1280 + argsToFold.add(0, foldedArgs);
32.1281 + Object result = target2.invokeVarargs(argsToPass);
32.1282 + if (verbosity >= 2)
32.1283 + System.out.println("result: "+result);
32.1284 + if (!expected.equals(result))
32.1285 + System.out.println("*** fail at n/p/f = "+nargs+"/"+pos+"/"+fold+": "+argsToPass+" => "+result);
32.1286 + assertEquals(expected, result);
32.1287 + }
32.1288 +
32.1289 + @Test
32.1290 + public void testDropArguments() throws Throwable {
32.1291 + if (CAN_SKIP_WORKING) return;
32.1292 + startTest("dropArguments");
32.1293 + for (int nargs = 0; nargs <= 4; nargs++) {
32.1294 + for (int drop = 1; drop <= 4; drop++) {
32.1295 + for (int pos = 0; pos <= nargs; pos++) {
32.1296 + testDropArguments(nargs, pos, drop);
32.1297 + }
32.1298 + }
32.1299 + }
32.1300 + }
32.1301 +
32.1302 + void testDropArguments(int nargs, int pos, int drop) throws Throwable {
32.1303 + countTest();
32.1304 + MethodHandle target = ValueConversions.varargsArray(nargs);
32.1305 + Object[] args = randomArgs(target.type().parameterArray());
32.1306 + MethodHandle target2 = MethodHandles.dropArguments(target, pos,
32.1307 + Collections.nCopies(drop, Object.class).toArray(new Class[0]));
32.1308 + List<Object> resList = Arrays.asList(args);
32.1309 + List<Object> argsToDrop = new ArrayList<Object>(resList);
32.1310 + for (int i = drop; i > 0; i--) {
32.1311 + argsToDrop.add(pos, "blort#"+i);
32.1312 + }
32.1313 + Object res2 = target2.invokeVarargs(argsToDrop);
32.1314 + Object res2List = Arrays.asList((Object[])res2);
32.1315 + //if (!resList.equals(res2List))
32.1316 + // System.out.println("*** fail at n/p/d = "+nargs+"/"+pos+"/"+drop+": "+argsToDrop+" => "+res2List);
32.1317 + assertEquals(resList, res2List);
32.1318 + }
32.1319 +
32.1320 + @Test
32.1321 + public void testInvokers() throws Throwable {
32.1322 + if (CAN_SKIP_WORKING) return;
32.1323 + startTest("exactInvoker, genericInvoker, varargsInvoker, dynamicInvoker");
32.1324 + // exactInvoker, genericInvoker, varargsInvoker[0..N], dynamicInvoker
32.1325 + Set<MethodType> done = new HashSet<MethodType>();
32.1326 + for (int i = 0; i <= 6; i++) {
32.1327 + MethodType gtype = MethodType.genericMethodType(i);
32.1328 + for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {
32.1329 + for (int j = -1; j < i; j++) {
32.1330 + MethodType type = gtype;
32.1331 + if (j < 0)
32.1332 + type = type.changeReturnType(argType);
32.1333 + else if (argType == void.class)
32.1334 + continue;
32.1335 + else
32.1336 + type = type.changeParameterType(j, argType);
32.1337 + if (argType.isPrimitive() && j != i-1) continue; // FIXME Fail_5
32.1338 + if (done.add(type))
32.1339 + testInvokers(type);
32.1340 + MethodType vtype = type.changeReturnType(void.class);
32.1341 + if (done.add(vtype))
32.1342 + testInvokers(vtype);
32.1343 + }
32.1344 + }
32.1345 + }
32.1346 + }
32.1347 +
32.1348 + public void testInvokers(MethodType type) throws Throwable {
32.1349 + if (verbosity >= 2)
32.1350 + System.out.println("test invokers for "+type);
32.1351 + int nargs = type.parameterCount();
32.1352 + boolean testRetCode = type.returnType() != void.class;
32.1353 + MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "invokee",
32.1354 + MethodType.genericMethodType(0, true));
32.1355 + target = MethodHandles.collectArguments(target, type);
32.1356 + Object[] args = randomArgs(type.parameterArray());
32.1357 + List<Object> targetPlusArgs = new ArrayList<Object>(Arrays.asList(args));
32.1358 + targetPlusArgs.add(0, target);
32.1359 + int code = (Integer) invokee(args);
32.1360 + Object log = logEntry("invokee", args);
32.1361 + assertEquals(log.hashCode(), code);
32.1362 + assertCalled("invokee", args);
32.1363 + MethodHandle inv;
32.1364 + Object result;
32.1365 + // exact invoker
32.1366 + countTest();
32.1367 + calledLog.clear();
32.1368 + inv = MethodHandles.exactInvoker(type);
32.1369 + result = inv.invokeVarargs(targetPlusArgs);
32.1370 + if (testRetCode) assertEquals(code, result);
32.1371 + assertCalled("invokee", args);
32.1372 + // generic invoker
32.1373 + countTest();
32.1374 + inv = MethodHandles.genericInvoker(type);
32.1375 + if (nargs <= 3) {
32.1376 + calledLog.clear();
32.1377 + switch (nargs) {
32.1378 + case 0:
32.1379 + result = inv.invoke(target);
32.1380 + break;
32.1381 + case 1:
32.1382 + result = inv.invoke(target, args[0]);
32.1383 + break;
32.1384 + case 2:
32.1385 + result = inv.invoke(target, args[0], args[1]);
32.1386 + break;
32.1387 + case 3:
32.1388 + result = inv.invoke(target, args[0], args[1], args[2]);
32.1389 + break;
32.1390 + }
32.1391 + if (testRetCode) assertEquals(code, result);
32.1392 + assertCalled("invokee", args);
32.1393 + }
32.1394 + calledLog.clear();
32.1395 + result = inv.invokeVarargs(targetPlusArgs);
32.1396 + if (testRetCode) assertEquals(code, result);
32.1397 + assertCalled("invokee", args);
32.1398 + // varargs invoker #0
32.1399 + calledLog.clear();
32.1400 + inv = MethodHandles.varargsInvoker(type, 0);
32.1401 + result = inv.invoke(target, args);
32.1402 + if (testRetCode) assertEquals(code, result);
32.1403 + assertCalled("invokee", args);
32.1404 + if (nargs >= 1) {
32.1405 + // varargs invoker #1
32.1406 + calledLog.clear();
32.1407 + inv = MethodHandles.varargsInvoker(type, 1);
32.1408 + result = inv.invoke(target, args[0], Arrays.copyOfRange(args, 1, nargs));
32.1409 + if (testRetCode) assertEquals(code, result);
32.1410 + assertCalled("invokee", args);
32.1411 + }
32.1412 + if (nargs >= 2) {
32.1413 + // varargs invoker #2
32.1414 + calledLog.clear();
32.1415 + inv = MethodHandles.varargsInvoker(type, 2);
32.1416 + result = inv.invoke(target, args[0], args[1], Arrays.copyOfRange(args, 2, nargs));
32.1417 + if (testRetCode) assertEquals(code, result);
32.1418 + assertCalled("invokee", args);
32.1419 + }
32.1420 + if (nargs >= 3) {
32.1421 + // varargs invoker #3
32.1422 + calledLog.clear();
32.1423 + inv = MethodHandles.varargsInvoker(type, 3);
32.1424 + result = inv.invoke(target, args[0], args[1], args[2], Arrays.copyOfRange(args, 3, nargs));
32.1425 + if (testRetCode) assertEquals(code, result);
32.1426 + assertCalled("invokee", args);
32.1427 + }
32.1428 + for (int k = 0; k <= nargs; k++) {
32.1429 + // varargs invoker #0..N
32.1430 + countTest();
32.1431 + calledLog.clear();
32.1432 + inv = MethodHandles.varargsInvoker(type, k);
32.1433 + List<Object> targetPlusVarArgs = new ArrayList<Object>(targetPlusArgs);
32.1434 + List<Object> tailList = targetPlusVarArgs.subList(1+k, 1+nargs);
32.1435 + Object[] tail = tailList.toArray();
32.1436 + tailList.clear(); tailList.add(tail);
32.1437 + result = inv.invokeVarargs(targetPlusVarArgs);
32.1438 + if (testRetCode) assertEquals(code, result);
32.1439 + assertCalled("invokee", args);
32.1440 + }
32.1441 + // dynamic invoker
32.1442 + countTest();
32.1443 + CallSite site = new CallSite(MethodHandlesTest.class, "foo", type);
32.1444 + inv = MethodHandles.dynamicInvoker(site);
32.1445 + site.setTarget(target);
32.1446 + calledLog.clear();
32.1447 + result = inv.invokeVarargs(args);
32.1448 + if (testRetCode) assertEquals(code, result);
32.1449 + assertCalled("invokee", args);
32.1450 + }
32.1451 +
32.1452 + static Object invokee(Object... args) {
32.1453 + return called("invokee", args).hashCode();
32.1454 + }
32.1455 +
32.1456 + private static final String MISSING_ARG = "missingArg";
32.1457 + static Object targetIfEquals() {
32.1458 + return called("targetIfEquals");
32.1459 + }
32.1460 + static Object fallbackIfNotEquals() {
32.1461 + return called("fallbackIfNotEquals");
32.1462 + }
32.1463 + static Object targetIfEquals(Object x) {
32.1464 + assertEquals(x, MISSING_ARG);
32.1465 + return called("targetIfEquals", x);
32.1466 + }
32.1467 + static Object fallbackIfNotEquals(Object x) {
32.1468 + assertFalse(x.toString(), x.equals(MISSING_ARG));
32.1469 + return called("fallbackIfNotEquals", x);
32.1470 + }
32.1471 + static Object targetIfEquals(Object x, Object y) {
32.1472 + assertEquals(x, y);
32.1473 + return called("targetIfEquals", x, y);
32.1474 + }
32.1475 + static Object fallbackIfNotEquals(Object x, Object y) {
32.1476 + assertFalse(x.toString(), x.equals(y));
32.1477 + return called("fallbackIfNotEquals", x, y);
32.1478 + }
32.1479 + static Object targetIfEquals(Object x, Object y, Object z) {
32.1480 + assertEquals(x, y);
32.1481 + return called("targetIfEquals", x, y, z);
32.1482 + }
32.1483 + static Object fallbackIfNotEquals(Object x, Object y, Object z) {
32.1484 + assertFalse(x.toString(), x.equals(y));
32.1485 + return called("fallbackIfNotEquals", x, y, z);
32.1486 + }
32.1487 +
32.1488 + @Test
32.1489 + public void testGuardWithTest() throws Throwable {
32.1490 + if (CAN_SKIP_WORKING) return;
32.1491 + startTest("guardWithTest");
32.1492 + for (int nargs = 0; nargs <= 3; nargs++) {
32.1493 + if (nargs != 2) continue; // FIXME: test more later
32.1494 + testGuardWithTest(nargs, Object.class);
32.1495 + testGuardWithTest(nargs, String.class);
32.1496 + }
32.1497 + }
32.1498 + void testGuardWithTest(int nargs, Class<?> argClass) throws Throwable {
32.1499 + countTest();
32.1500 + MethodHandle test = PRIVATE.findVirtual(Object.class, "equals", MethodType.methodType(boolean.class, Object.class));
32.1501 + MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "targetIfEquals", MethodType.genericMethodType(nargs));
32.1502 + MethodHandle fallback = PRIVATE.findStatic(MethodHandlesTest.class, "fallbackIfNotEquals", MethodType.genericMethodType(nargs));
32.1503 + while (test.type().parameterCount() < nargs)
32.1504 + test = MethodHandles.dropArguments(test, test.type().parameterCount()-1, Object.class);
32.1505 + while (test.type().parameterCount() > nargs)
32.1506 + test = MethodHandles.insertArguments(test, 0, MISSING_ARG);
32.1507 + if (argClass != Object.class) {
32.1508 + test = changeArgTypes(test, argClass);
32.1509 + target = changeArgTypes(target, argClass);
32.1510 + fallback = changeArgTypes(fallback, argClass);
32.1511 + }
32.1512 + MethodHandle mh = MethodHandles.guardWithTest(test, target, fallback);
32.1513 + assertEquals(target.type(), mh.type());
32.1514 + Object[][] argLists = {
32.1515 + { },
32.1516 + { "foo" }, { MISSING_ARG },
32.1517 + { "foo", "foo" }, { "foo", "bar" },
32.1518 + { "foo", "foo", "baz" }, { "foo", "bar", "baz" }
32.1519 + };
32.1520 + for (Object[] argList : argLists) {
32.1521 + if (argList.length != nargs) continue;
32.1522 + boolean equals;
32.1523 + switch (nargs) {
32.1524 + case 0: equals = true; break;
32.1525 + case 1: equals = MISSING_ARG.equals(argList[0]); break;
32.1526 + default: equals = argList[0].equals(argList[1]); break;
32.1527 + }
32.1528 + String willCall = (equals ? "targetIfEquals" : "fallbackIfNotEquals");
32.1529 + if (verbosity >= 2)
32.1530 + System.out.println(logEntry(willCall, argList));
32.1531 + Object result = mh.invokeVarargs(argList);
32.1532 + assertCalled(willCall, argList);
32.1533 + }
32.1534 + }
32.1535 +
32.1536 + @Test
32.1537 + public void testCatchException() throws Throwable {
32.1538 + if (CAN_SKIP_WORKING) return;
32.1539 + startTest("catchException");
32.1540 + for (int nargs = 2; nargs <= 6; nargs++) {
32.1541 + for (int ti = 0; ti <= 1; ti++) {
32.1542 + boolean throwIt = (ti != 0);
32.1543 + testCatchException(int.class, new ClassCastException("testing"), throwIt, nargs);
32.1544 + testCatchException(void.class, new java.io.IOException("testing"), throwIt, nargs);
32.1545 + testCatchException(String.class, new LinkageError("testing"), throwIt, nargs);
32.1546 + }
32.1547 + }
32.1548 + }
32.1549 +
32.1550 + private static <T extends Throwable>
32.1551 + Object throwOrReturn(Object normal, T exception) throws T {
32.1552 + if (exception != null) throw exception;
32.1553 + return normal;
32.1554 + }
32.1555 +
32.1556 + void testCatchException(Class<?> returnType, Throwable thrown, boolean throwIt, int nargs) throws Throwable {
32.1557 + countTest();
32.1558 + if (verbosity >= 2)
32.1559 + System.out.println("catchException rt="+returnType+" throw="+throwIt+" nargs="+nargs);
32.1560 + Class<? extends Throwable> exType = thrown.getClass();
32.1561 + MethodHandle throwOrReturn
32.1562 + = PRIVATE.findStatic(MethodHandlesTest.class, "throwOrReturn",
32.1563 + MethodType.methodType(Object.class, Object.class, Throwable.class));
32.1564 + MethodHandle thrower = throwOrReturn;
32.1565 + while (thrower.type().parameterCount() < nargs)
32.1566 + thrower = MethodHandles.dropArguments(thrower, thrower.type().parameterCount(), Object.class);
32.1567 + MethodHandle target = MethodHandles.catchException(thrower,
32.1568 + thrown.getClass(), ValueConversions.varargsList(1+nargs));
32.1569 + assertEquals(thrower.type(), target.type());
32.1570 + //System.out.println("catching with "+target+" : "+throwOrReturn);
32.1571 + Object[] args = randomArgs(nargs, Object.class);
32.1572 + args[1] = (throwIt ? thrown : null);
32.1573 + Object returned = target.invokeVarargs(args);
32.1574 + //System.out.println("return from "+target+" : "+returned);
32.1575 + if (!throwIt) {
32.1576 + assertSame(args[0], returned);
32.1577 + } else {
32.1578 + List<Object> catchArgs = new ArrayList<Object>(Arrays.asList(args));
32.1579 + catchArgs.add(0, thrown);
32.1580 + assertEquals(catchArgs, returned);
32.1581 + }
32.1582 + }
32.1583 +
32.1584 + @Test
32.1585 + public void testThrowException() throws Throwable {
32.1586 + if (CAN_SKIP_WORKING) return;
32.1587 + startTest("throwException");
32.1588 + testThrowException(int.class, new ClassCastException("testing"));
32.1589 + testThrowException(void.class, new java.io.IOException("testing"));
32.1590 + testThrowException(String.class, new LinkageError("testing"));
32.1591 + }
32.1592 +
32.1593 + void testThrowException(Class<?> returnType, Throwable thrown) throws Throwable {
32.1594 + countTest();
32.1595 + Class<? extends Throwable> exType = thrown.getClass();
32.1596 + MethodHandle target = MethodHandles.throwException(returnType, exType);
32.1597 + //System.out.println("throwing with "+target+" : "+thrown);
32.1598 + MethodType expectedType = MethodType.methodType(returnType, exType);
32.1599 + assertEquals(expectedType, target.type());
32.1600 + Throwable caught = null;
32.1601 + try {
32.1602 + Object res = target.invokeGeneric(thrown);
32.1603 + fail("got "+res+" instead of throwing "+thrown);
32.1604 + } catch (Throwable ex) {
32.1605 + if (ex != thrown) {
32.1606 + if (ex instanceof Error) throw (Error)ex;
32.1607 + if (ex instanceof RuntimeException) throw (RuntimeException)ex;
32.1608 + }
32.1609 + caught = ex;
32.1610 + }
32.1611 + assertSame(thrown, caught);
32.1612 + }
32.1613 +
32.1614 + @Test
32.1615 + public void testCastFailure() throws Throwable {
32.1616 + if (CAN_SKIP_WORKING) return;
32.1617 + startTest("testCastFailure");
32.1618 + testCastFailure("cast/argument", 11000);
32.1619 + testCastFailure("unbox/argument", 11000);
32.1620 + testCastFailure("cast/return", 11000);
32.1621 + testCastFailure("unbox/return", 11000);
32.1622 + }
32.1623 +
32.1624 + static class Surprise extends JavaMethodHandle {
32.1625 + Surprise() { super("value"); }
32.1626 + Object value(Object x) {
32.1627 + trace("value", x);
32.1628 + if (boo != null) return boo;
32.1629 + return x;
32.1630 + }
32.1631 + Object boo;
32.1632 + void boo(Object x) { boo = x; }
32.1633 +
32.1634 + static void trace(String x, Object y) {
32.1635 + if (verbosity > 8) System.out.println(x+"="+y);
32.1636 + }
32.1637 + static Object refIdentity(Object x) { trace("ref.x", x); return x; }
32.1638 + static Integer boxIdentity(Integer x) { trace("box.x", x); return x; }
32.1639 + static int intIdentity(int x) { trace("int.x", x); return x; }
32.1640 + static MethodHandle REF_IDENTITY = PRIVATE.findStatic(
32.1641 + Surprise.class, "refIdentity",
32.1642 + MethodType.methodType(Object.class, Object.class));
32.1643 + static MethodHandle BOX_IDENTITY = PRIVATE.findStatic(
32.1644 + Surprise.class, "boxIdentity",
32.1645 + MethodType.methodType(Integer.class, Integer.class));
32.1646 + static MethodHandle INT_IDENTITY = PRIVATE.findStatic(
32.1647 + Surprise.class, "intIdentity",
32.1648 + MethodType.methodType(int.class, int.class));
32.1649 + }
32.1650 +
32.1651 + void testCastFailure(String mode, int okCount) throws Throwable {
32.1652 + countTest(false);
32.1653 + if (verbosity > 1) System.out.println("mode="+mode);
32.1654 + Surprise boo = new Surprise();
32.1655 + MethodHandle identity = Surprise.REF_IDENTITY, surprise = boo;
32.1656 + if (mode.endsWith("/return")) {
32.1657 + if (mode.equals("unbox/return")) {
32.1658 + // fail on return to ((Integer)surprise).intValue
32.1659 + surprise = MethodHandles.convertArguments(surprise, MethodType.methodType(int.class, Object.class));
32.1660 + identity = MethodHandles.convertArguments(identity, MethodType.methodType(int.class, Object.class));
32.1661 + } else if (mode.equals("cast/return")) {
32.1662 + // fail on return to (Integer)surprise
32.1663 + surprise = MethodHandles.convertArguments(surprise, MethodType.methodType(Integer.class, Object.class));
32.1664 + identity = MethodHandles.convertArguments(identity, MethodType.methodType(Integer.class, Object.class));
32.1665 + }
32.1666 + } else if (mode.endsWith("/argument")) {
32.1667 + MethodHandle callee = null;
32.1668 + if (mode.equals("unbox/argument")) {
32.1669 + // fail on handing surprise to int argument
32.1670 + callee = Surprise.INT_IDENTITY;
32.1671 + } else if (mode.equals("cast/argument")) {
32.1672 + // fail on handing surprise to Integer argument
32.1673 + callee = Surprise.BOX_IDENTITY;
32.1674 + }
32.1675 + if (callee != null) {
32.1676 + callee = MethodHandles.convertArguments(callee, MethodType.genericMethodType(1));
32.1677 + surprise = MethodHandles.filterArguments(callee, surprise);
32.1678 + identity = MethodHandles.filterArguments(callee, identity);
32.1679 + }
32.1680 + }
32.1681 + assertNotSame(mode, surprise, boo);
32.1682 + identity = MethodHandles.convertArguments(identity, MethodType.genericMethodType(1));
32.1683 + surprise = MethodHandles.convertArguments(surprise, MethodType.genericMethodType(1));
32.1684 + Object x = 42;
32.1685 + for (int i = 0; i < okCount; i++) {
32.1686 + Object y = identity.invoke(x);
32.1687 + assertEquals(x, y);
32.1688 + Object z = surprise.invoke(x);
32.1689 + assertEquals(x, z);
32.1690 + }
32.1691 + boo.boo("Boo!");
32.1692 + Object y = identity.invoke(x);
32.1693 + assertEquals(x, y);
32.1694 + try {
32.1695 + Object z = surprise.invoke(x);
32.1696 + System.out.println("Failed to throw; got z="+z);
32.1697 + assertTrue(false);
32.1698 + } catch (Exception ex) {
32.1699 + if (verbosity > 1)
32.1700 + System.out.println("caught "+ex);
32.1701 + if (verbosity > 2)
32.1702 + ex.printStackTrace();
32.1703 + assertTrue(ex instanceof ClassCastException
32.1704 + // FIXME: accept only one of the two for any given unit test
32.1705 + || ex instanceof WrongMethodTypeException
32.1706 + );
32.1707 + }
32.1708 + }
32.1709 +
32.1710 +}
32.1711 +// Local abbreviated copy of sun.dyn.util.ValueConversions
32.1712 +class ValueConversions {
32.1713 + private static final Lookup IMPL_LOOKUP = MethodHandles.lookup();
32.1714 + private static final Object[] NO_ARGS_ARRAY = {};
32.1715 + private static Object[] makeArray(Object... args) { return args; }
32.1716 + private static Object[] array() { return NO_ARGS_ARRAY; }
32.1717 + private static Object[] array(Object a0)
32.1718 + { return makeArray(a0); }
32.1719 + private static Object[] array(Object a0, Object a1)
32.1720 + { return makeArray(a0, a1); }
32.1721 + private static Object[] array(Object a0, Object a1, Object a2)
32.1722 + { return makeArray(a0, a1, a2); }
32.1723 + private static Object[] array(Object a0, Object a1, Object a2, Object a3)
32.1724 + { return makeArray(a0, a1, a2, a3); }
32.1725 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1726 + Object a4)
32.1727 + { return makeArray(a0, a1, a2, a3, a4); }
32.1728 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1729 + Object a4, Object a5)
32.1730 + { return makeArray(a0, a1, a2, a3, a4, a5); }
32.1731 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1732 + Object a4, Object a5, Object a6)
32.1733 + { return makeArray(a0, a1, a2, a3, a4, a5, a6); }
32.1734 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1735 + Object a4, Object a5, Object a6, Object a7)
32.1736 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7); }
32.1737 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1738 + Object a4, Object a5, Object a6, Object a7,
32.1739 + Object a8)
32.1740 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
32.1741 + private static Object[] array(Object a0, Object a1, Object a2, Object a3,
32.1742 + Object a4, Object a5, Object a6, Object a7,
32.1743 + Object a8, Object a9)
32.1744 + { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
32.1745 + static MethodHandle[] makeArrays() {
32.1746 + ArrayList<MethodHandle> arrays = new ArrayList<MethodHandle>();
32.1747 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
32.1748 + for (;;) {
32.1749 + int nargs = arrays.size();
32.1750 + MethodType type = MethodType.genericMethodType(nargs).changeReturnType(Object[].class);
32.1751 + String name = "array";
32.1752 + MethodHandle array = null;
32.1753 + try {
32.1754 + array = lookup.findStatic(ValueConversions.class, name, type);
32.1755 + } catch (NoAccessException ex) {
32.1756 + }
32.1757 + if (array == null) break;
32.1758 + arrays.add(array);
32.1759 + }
32.1760 + assert(arrays.size() == 11); // current number of methods
32.1761 + return arrays.toArray(new MethodHandle[0]);
32.1762 + }
32.1763 + static final MethodHandle[] ARRAYS = makeArrays();
32.1764 +
32.1765 + /** Return a method handle that takes the indicated number of Object
32.1766 + * arguments and returns an Object array of them, as if for varargs.
32.1767 + */
32.1768 + public static MethodHandle varargsArray(int nargs) {
32.1769 + if (nargs < ARRAYS.length)
32.1770 + return ARRAYS[nargs];
32.1771 + // else need to spin bytecode or do something else fancy
32.1772 + throw new UnsupportedOperationException("NYI");
32.1773 + }
32.1774 +
32.1775 + private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);
32.1776 + private static List<Object> makeList(Object... args) { return Arrays.asList(args); }
32.1777 + private static List<Object> list() { return NO_ARGS_LIST; }
32.1778 + private static List<Object> list(Object a0)
32.1779 + { return makeList(a0); }
32.1780 + private static List<Object> list(Object a0, Object a1)
32.1781 + { return makeList(a0, a1); }
32.1782 + private static List<Object> list(Object a0, Object a1, Object a2)
32.1783 + { return makeList(a0, a1, a2); }
32.1784 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3)
32.1785 + { return makeList(a0, a1, a2, a3); }
32.1786 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1787 + Object a4)
32.1788 + { return makeList(a0, a1, a2, a3, a4); }
32.1789 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1790 + Object a4, Object a5)
32.1791 + { return makeList(a0, a1, a2, a3, a4, a5); }
32.1792 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1793 + Object a4, Object a5, Object a6)
32.1794 + { return makeList(a0, a1, a2, a3, a4, a5, a6); }
32.1795 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1796 + Object a4, Object a5, Object a6, Object a7)
32.1797 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7); }
32.1798 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1799 + Object a4, Object a5, Object a6, Object a7,
32.1800 + Object a8)
32.1801 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8); }
32.1802 + private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
32.1803 + Object a4, Object a5, Object a6, Object a7,
32.1804 + Object a8, Object a9)
32.1805 + { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
32.1806 + static MethodHandle[] makeLists() {
32.1807 + ArrayList<MethodHandle> arrays = new ArrayList<MethodHandle>();
32.1808 + MethodHandles.Lookup lookup = IMPL_LOOKUP;
32.1809 + for (;;) {
32.1810 + int nargs = arrays.size();
32.1811 + MethodType type = MethodType.genericMethodType(nargs).changeReturnType(List.class);
32.1812 + String name = "list";
32.1813 + MethodHandle array = null;
32.1814 + try {
32.1815 + array = lookup.findStatic(ValueConversions.class, name, type);
32.1816 + } catch (NoAccessException ex) {
32.1817 + }
32.1818 + if (array == null) break;
32.1819 + arrays.add(array);
32.1820 + }
32.1821 + assert(arrays.size() == 11); // current number of methods
32.1822 + return arrays.toArray(new MethodHandle[0]);
32.1823 + }
32.1824 + static final MethodHandle[] LISTS = makeLists();
32.1825 +
32.1826 + /** Return a method handle that takes the indicated number of Object
32.1827 + * arguments and returns List.
32.1828 + */
32.1829 + public static MethodHandle varargsList(int nargs) {
32.1830 + if (nargs < LISTS.length)
32.1831 + return LISTS[nargs];
32.1832 + // else need to spin bytecode or do something else fancy
32.1833 + throw new UnsupportedOperationException("NYI");
32.1834 + }
32.1835 +}
32.1836 +// This guy tests access from outside the same package member, but inside
32.1837 +// the package itself.
32.1838 +class PackageSibling {
32.1839 + static Lookup lookup() {
32.1840 + return MethodHandles.lookup();
32.1841 + }
32.1842 +}