Home » openjdk-7 » java.lang.invoke » [javadoc | source]

    1   /*
    2    * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   
   26   package java.lang.invoke;
   27   
   28   import sun.invoke.util.ValueConversions;
   29   import sun.invoke.util.Wrapper;
   30   import java.lang.reflect;
   31   import static java.lang.invoke.MethodHandleStatics.*;
   32   import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
   33   
   34   /**
   35    * Adapters which mediate between incoming calls which are generic
   36    * and outgoing calls which are not.  Any call can be represented generically
   37    * boxing up its arguments, and (on return) unboxing the return value.
   38    * <p>
   39    * A call is "generic" (in MethodHandle terms) if its MethodType features
   40    * only Object arguments.  A non-generic call therefore features
   41    * primitives and/or reference types other than Object.
   42    * An adapter has types for its incoming and outgoing calls.
   43    * The incoming call type is simply determined by the adapter's type
   44    * (the MethodType it presents to callers).  The outgoing call type
   45    * is determined by the adapter's target (a MethodHandle that the adapter
   46    * either binds internally or else takes as a leading argument).
   47    * (To stretch the term, adapter-like method handles may have multiple
   48    * targets or be polymorphic across multiple call types.)
   49    * @author jrose
   50    */
   51   class FromGeneric {
   52       // type for the outgoing call (may have primitives, etc.)
   53       private final MethodType targetType;
   54       // type of the outgoing call internal to the adapter
   55       private final MethodType internalType;
   56       // prototype adapter (clone and customize for each new target!)
   57       private final Adapter adapter;
   58       // entry point for adapter (Adapter mh, a...) => ...
   59       private final MethodHandle entryPoint;
   60       // unboxing invoker of type (MH, Object**N) => raw return value
   61       // it makes up the difference of internalType => targetType
   62       private final MethodHandle unboxingInvoker;
   63       // conversion which boxes a the target's raw return value
   64       private final MethodHandle returnConversion;
   65   
   66       /** Compute and cache information common to all unboxing adapters
   67        *  that can call out to targets of the erasure-family of the given erased type.
   68        */
   69       private FromGeneric(MethodType targetType) {
   70           this.targetType = targetType;
   71           MethodType internalType0;
   72           // the target invoker will generally need casts on reference arguments
   73           Adapter ad = findAdapter(internalType0 = targetType.erase());
   74           if (ad != null) {
   75               // Immediate hit to exactly the adapter we want,
   76               // with no monkeying around with primitive types.
   77               this.internalType = internalType0;
   78               this.adapter = ad;
   79               this.entryPoint = ad.prototypeEntryPoint();
   80               this.returnConversion = computeReturnConversion(targetType, internalType0);
   81               this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
   82               return;
   83           }
   84   
   85           // outgoing primitive arguments will be wrapped; unwrap them
   86           MethodType primsAsObj = targetType.form().primArgsAsBoxes();
   87           MethodType objArgsRawRet = primsAsObj.form().primsAsInts();
   88           if (objArgsRawRet != targetType)
   89               ad = findAdapter(internalType0 = objArgsRawRet);
   90           if (ad == null) {
   91               ad = buildAdapterFromBytecodes(internalType0 = targetType);
   92           }
   93           this.internalType = internalType0;
   94           this.adapter = ad;
   95           MethodType tepType = targetType.insertParameterTypes(0, adapter.getClass());
   96           this.entryPoint = ad.prototypeEntryPoint();
   97           this.returnConversion = computeReturnConversion(targetType, internalType0);
   98           this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
   99       }
  100   
  101       static {
  102           assert(MethodHandleNatives.workaroundWithoutRicochetFrames());  // this class is deprecated
  103       }
  104   
  105       /**
  106        * The typed target will be called according to targetType.
  107        * The adapter code will in fact see the raw result from internalType,
  108        * and must box it into an object.  Produce a converter for this.
  109        */
  110       private static MethodHandle computeReturnConversion(
  111               MethodType targetType, MethodType internalType) {
  112           Class<?> tret = targetType.returnType();
  113           Class<?> iret = internalType.returnType();
  114           Wrapper wrap = Wrapper.forBasicType(tret);
  115           if (!iret.isPrimitive()) {
  116               assert(iret == Object.class);
  117               return ValueConversions.identity();
  118           } else if (wrap.primitiveType() == iret) {
  119               return ValueConversions.box(wrap);
  120           } else {
  121               assert(tret == double.class ? iret == long.class : iret == int.class);
  122               return ValueConversions.boxRaw(wrap);
  123           }
  124       }
  125   
  126       /**
  127        * The typed target will need an exact invocation point; provide it here.
  128        * The adapter will possibly need to make a slightly different call,
  129        * so adapt the invoker.  This way, the logic for making up the
  130        * difference between what the adapter can call and what the target
  131        * needs can be cached once per type.
  132        */
  133       private static MethodHandle computeUnboxingInvoker(
  134               MethodType targetType, MethodType internalType) {
  135           // All the adapters we have here have reference-untyped internal calls.
  136           assert(internalType == internalType.erase());
  137           MethodHandle invoker = targetType.invokers().exactInvoker();
  138           // cast all narrow reference types, unbox all primitive arguments:
  139           MethodType fixArgsType = internalType.changeReturnType(targetType.returnType());
  140           MethodHandle fixArgs = MethodHandleImpl.convertArguments(
  141                                    invoker, Invokers.invokerType(fixArgsType),
  142                                    invoker.type(), 0);
  143           if (fixArgs == null)
  144               throw new InternalError("bad fixArgs");
  145           // reinterpret the calling sequence as raw:
  146           MethodHandle retyper = AdapterMethodHandle.makeRetypeRaw(
  147                                           Invokers.invokerType(internalType), fixArgs);
  148           if (retyper == null)
  149               throw new InternalError("bad retyper");
  150           return retyper;
  151       }
  152   
  153       Adapter makeInstance(MethodHandle typedTarget) {
  154           MethodType type = typedTarget.type();
  155           if (type == targetType) {
  156               return adapter.makeInstance(entryPoint, unboxingInvoker, returnConversion, typedTarget);
  157           }
  158           // my erased-type is not exactly the same as the desired type
  159           assert(type.erase() == targetType);  // else we are busted
  160           MethodHandle invoker = computeUnboxingInvoker(type, internalType);
  161           return adapter.makeInstance(entryPoint, invoker, returnConversion, typedTarget);
  162       }
  163   
  164       /** Build an adapter of the given generic type, which invokes typedTarget
  165        *  on the incoming arguments, after unboxing as necessary.
  166        *  The return value is boxed if necessary.
  167        * @param typedTarget the target
  168        * @return an adapter method handle
  169        */
  170       public static MethodHandle make(MethodHandle typedTarget) {
  171           MethodType type = typedTarget.type();
  172           if (type == type.generic())  return typedTarget;
  173           return FromGeneric.of(type).makeInstance(typedTarget);
  174       }
  175   
  176       /** Return the adapter information for this type's erasure. */
  177       static FromGeneric of(MethodType type) {
  178           MethodTypeForm form = type.form();
  179           FromGeneric fromGen = form.fromGeneric;
  180           if (fromGen == null)
  181               form.fromGeneric = fromGen = new FromGeneric(form.erasedType());
  182           return fromGen;
  183       }
  184   
  185       public String toString() {
  186           return "FromGeneric"+targetType;
  187       }
  188   
  189       /* Create an adapter that handles spreading calls for the given type. */
  190       static Adapter findAdapter(MethodType internalType) {
  191           MethodType entryType = internalType.generic();
  192           MethodTypeForm form = internalType.form();
  193           Class<?> rtype = internalType.returnType();
  194           int argc = form.parameterCount();
  195           int lac = form.longPrimitiveParameterCount();
  196           int iac = form.primitiveParameterCount() - lac;
  197           String intsAndLongs = (iac > 0 ? "I"+iac : "")+(lac > 0 ? "J"+lac : "");
  198           String rawReturn = String.valueOf(Wrapper.forPrimitiveType(rtype).basicTypeChar());
  199           String cname0 = rawReturn + argc;
  200           String cname1 = "A"       + argc;
  201           String[] cnames = { cname0+intsAndLongs, cname0, cname1+intsAndLongs, cname1 };
  202           String iname = "invoke_"+cname0+intsAndLongs;
  203           // e.g., D5I2, D5, L5I2, L5; invoke_D5
  204           for (String cname : cnames) {
  205               Class<? extends Adapter> acls = Adapter.findSubClass(cname);
  206               if (acls == null)  continue;
  207               // see if it has the required invoke method
  208               MethodHandle entryPoint = null;
  209               try {
  210                   entryPoint = IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);
  211               } catch (ReflectiveOperationException ex) {
  212               }
  213               if (entryPoint == null)  continue;
  214               Constructor<? extends Adapter> ctor = null;
  215               try {
  216                   ctor = acls.getDeclaredConstructor(MethodHandle.class);
  217               } catch (NoSuchMethodException ex) {
  218               } catch (SecurityException ex) {
  219               }
  220               if (ctor == null)  continue;
  221               try {
  222                   // Produce an instance configured as a prototype.
  223                   return ctor.newInstance(entryPoint);
  224               } catch (IllegalArgumentException ex) {
  225               } catch (InvocationTargetException wex) {
  226                   Throwable ex = wex.getTargetException();
  227                   if (ex instanceof Error)  throw (Error)ex;
  228                   if (ex instanceof RuntimeException)  throw (RuntimeException)ex;
  229               } catch (InstantiationException ex) {
  230               } catch (IllegalAccessException ex) {
  231               }
  232           }
  233           return null;
  234       }
  235   
  236       static Adapter buildAdapterFromBytecodes(MethodType internalType) {
  237           throw new UnsupportedOperationException("NYI "+internalType);
  238       }
  239   
  240       /**
  241        * This adapter takes some untyped arguments, and returns an untyped result.
  242        * Internally, it applies the invoker to the target, which causes the
  243        * objects to be unboxed; the result is a raw type in L/I/J/F/D.
  244        * This result is passed to convert, which is responsible for
  245        * converting the raw result into a boxed object.
  246        * The invoker is kept separate from the target because it can be
  247        * generated once per type erasure family, and reused across adapters.
  248        */
  249       static abstract class Adapter extends BoundMethodHandle {
  250           /*
  251            * class X<<R,int N>> extends Adapter {
  252            *   (MH, Object**N)=>raw(R) invoker;
  253            *   (any**N)=>R target;
  254            *   raw(R)=>Object convert;
  255            *   Object invoke(Object**N a) = convert(invoker(target, a...))
  256            * }
  257            */
  258           protected final MethodHandle invoker;  // (MH, Object**N) => raw(R)
  259           protected final MethodHandle convert;  // raw(R) => Object
  260           protected final MethodHandle target;   // (any**N) => R
  261   
  262           @Override
  263           String debugString() {
  264               return addTypeString(target, this);
  265           }
  266   
  267           protected boolean isPrototype() { return target == null; }
  268           protected Adapter(MethodHandle entryPoint) {
  269               this(entryPoint, null, entryPoint, null);
  270               assert(isPrototype());
  271           }
  272           protected MethodHandle prototypeEntryPoint() {
  273               if (!isPrototype())  throw new InternalError();
  274               return convert;
  275           }
  276   
  277           protected Adapter(MethodHandle entryPoint,
  278                             MethodHandle invoker, MethodHandle convert, MethodHandle target) {
  279               super(entryPoint);
  280               this.invoker = invoker;
  281               this.convert = convert;
  282               this.target  = target;
  283           }
  284   
  285           /** Make a copy of self, with new fields. */
  286           protected abstract Adapter makeInstance(MethodHandle entryPoint,
  287                   MethodHandle invoker, MethodHandle convert, MethodHandle target);
  288           // { return new ThisType(entryPoint, convert, target); }
  289   
  290           /// Conversions on the value returned from the target.
  291           protected Object convert_L(Object result) throws Throwable { return convert.invokeExact(result); }
  292           protected Object convert_I(int    result) throws Throwable { return convert.invokeExact(result); }
  293           protected Object convert_J(long   result) throws Throwable { return convert.invokeExact(result); }
  294           protected Object convert_F(float  result) throws Throwable { return convert.invokeExact(result); }
  295           protected Object convert_D(double result) throws Throwable { return convert.invokeExact(result); }
  296   
  297           static private final String CLASS_PREFIX; // "java.lang.invoke.FromGeneric$"
  298           static {
  299               String aname = Adapter.class.getName();
  300               String sname = Adapter.class.getSimpleName();
  301               if (!aname.endsWith(sname))  throw new InternalError();
  302               CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());
  303           }
  304           /** Find a sibing class of Adapter. */
  305           static Class<? extends Adapter> findSubClass(String name) {
  306               String cname = Adapter.CLASS_PREFIX + name;
  307               try {
  308                   return Class.forName(cname).asSubclass(Adapter.class);
  309               } catch (ClassNotFoundException ex) {
  310                   return null;
  311               } catch (ClassCastException ex) {
  312                   return null;
  313               }
  314           }
  315       }
  316   
  317       /* generated classes follow this pattern:
  318       static class xA2 extends Adapter {
  319           protected xA2(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  320           protected xA2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  321                           { super(e, i, c, t); }
  322           protected xA2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  323                           { return new xA2(e, i, c, t); }
  324           protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
  325           protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1)); }
  326           protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1)); }
  327           protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
  328           protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
  329       }
  330       // */
  331   
  332   /*
  333   : SHELL; n=FromGeneric; cp -p $n.java $n.java-; sed < $n.java- > $n.java+ -e '/{{*{{/,/}}*}}/w /tmp/genclasses.java' -e '/}}*}}/q'; (cd /tmp; javac -d . genclasses.java; java -cp . genclasses) >> $n.java+; echo '}' >> $n.java+; mv $n.java+ $n.java; mv $n.java- $n.java~
  334   //{{{
  335   import java.util;
  336   class genclasses {
  337       static String[] TYPES = { "Object",    "int   ",    "long  ",    "float ",    "double" };
  338       static String[] WRAPS = { "         ", "(Integer)", "(Long)   ", "(Float)  ", "(Double) " };
  339       static String[] TCHARS = { "L",     "I",      "J",      "F",      "D",     "A" };
  340       static String[][] TEMPLATES = { {
  341           "@for@ arity=0..10  rcat<=4 nrefs<=99 nints=0   nlongs=0",
  342           "    //@each-cat@",
  343           "    static class @cat@ extends Adapter {",
  344           "        protected @cat@(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype",
  345           "        protected @cat@(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
  346           "                        { super(e, i, c, t); }",
  347           "        protected @cat@ makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)",
  348           "                        { return new @cat@(e, i, c, t); }",
  349           "        //@each-R@",
  350           "        protected Object invoke_@catN@(@Tvav@) throws Throwable { return convert_@Rc@((@R@)@W@invoker.invokeExact(target@av@)); }",
  351           "        //@end-R@",
  352           "    }",
  353       } };
  354       static final String NEWLINE_INDENT = "\n                ";
  355       enum VAR {
  356           cat, catN, R, Rc, W, av, Tvav, Ovav;
  357           public final String pattern = "@"+toString().replace('_','.')+"@";
  358           public String binding;
  359           static void makeBindings(boolean topLevel, int rcat, int nrefs, int nints, int nlongs) {
  360               int nargs = nrefs + nints + nlongs;
  361               if (topLevel)
  362                   VAR.cat.binding = catstr(ALL_RETURN_TYPES ? TYPES.length : rcat, nrefs, nints, nlongs);
  363               VAR.catN.binding = catstr(rcat, nrefs, nints, nlongs);
  364               VAR.R.binding = TYPES[rcat];
  365               VAR.Rc.binding = TCHARS[rcat];
  366               VAR.W.binding = WRAPS[rcat];
  367               String[] Tv = new String[nargs];
  368               String[] av = new String[nargs];
  369               String[] Tvav = new String[nargs];
  370               String[] Ovav = new String[nargs];
  371               for (int i = 0; i < nargs; i++) {
  372                   int tcat = (i < nrefs) ? 0 : (i < nrefs + nints) ? 1 : 2;
  373                   Tv[i] = TYPES[tcat];
  374                   av[i] = arg(i);
  375                   Tvav[i] = param(Tv[i], av[i]);
  376                   Ovav[i] = param("Object", av[i]);
  377               }
  378               VAR.av.binding = comma(", ", av);
  379               VAR.Tvav.binding = comma(Tvav);
  380               VAR.Ovav.binding = comma(Ovav);
  381           }
  382           static String arg(int i) { return "a"+i; }
  383           static String param(String t, String a) { return t+" "+a; }
  384           static String comma(String[] v) { return comma("", v); }
  385           static String comma(String sep, String[] v) {
  386               if (v.length == 0)  return "";
  387               String res = sep+v[0];
  388               for (int i = 1; i < v.length; i++)  res += ", "+v[i];
  389               return res;
  390           }
  391           static String transform(String string) {
  392               for (VAR var : values())
  393                   string = string.replaceAll(var.pattern, var.binding);
  394               return string;
  395           }
  396       }
  397       static String[] stringsIn(String[] strings, int beg, int end) {
  398           return Arrays.copyOfRange(strings, beg, Math.min(end, strings.length));
  399       }
  400       static String[] stringsBefore(String[] strings, int pos) {
  401           return stringsIn(strings, 0, pos);
  402       }
  403       static String[] stringsAfter(String[] strings, int pos) {
  404           return stringsIn(strings, pos, strings.length);
  405       }
  406       static int indexAfter(String[] strings, int pos, String tag) {
  407           return Math.min(indexBefore(strings, pos, tag) + 1, strings.length);
  408       }
  409       static int indexBefore(String[] strings, int pos, String tag) {
  410           for (int i = pos, end = strings.length; ; i++) {
  411               if (i == end || strings[i].endsWith(tag))  return i;
  412           }
  413       }
  414       static int MIN_ARITY, MAX_ARITY, MAX_RCAT, MAX_REFS, MAX_INTS, MAX_LONGS;
  415       static boolean ALL_ARG_TYPES, ALL_RETURN_TYPES;
  416       static HashSet<String> done = new HashSet<String>();
  417       public static void main(String... av) {
  418           for (String[] template : TEMPLATES) {
  419               int forLinesLimit = indexBefore(template, 0, "@each-cat@");
  420               String[] forLines = stringsBefore(template, forLinesLimit);
  421               template = stringsAfter(template, forLinesLimit);
  422               for (String forLine : forLines)
  423                   expandTemplate(forLine, template);
  424           }
  425       }
  426       static void expandTemplate(String forLine, String[] template) {
  427           String[] params = forLine.split("[^0-9]+");
  428           if (params[0].length() == 0)  params = stringsAfter(params, 1);
  429           System.out.println("//params="+Arrays.asList(params));
  430           int pcur = 0;
  431           MIN_ARITY = Integer.valueOf(params[pcur++]);
  432           MAX_ARITY = Integer.valueOf(params[pcur++]);
  433           MAX_RCAT  = Integer.valueOf(params[pcur++]);
  434           MAX_REFS  = Integer.valueOf(params[pcur++]);
  435           MAX_INTS  = Integer.valueOf(params[pcur++]);
  436           MAX_LONGS = Integer.valueOf(params[pcur++]);
  437           if (pcur != params.length)  throw new RuntimeException("bad extra param: "+forLine);
  438           if (MAX_RCAT >= TYPES.length)  MAX_RCAT = TYPES.length - 1;
  439           ALL_ARG_TYPES = (indexBefore(template, 0, "@each-Tv@") < template.length);
  440           ALL_RETURN_TYPES = (indexBefore(template, 0, "@each-R@") < template.length);
  441           for (int nargs = MIN_ARITY; nargs <= MAX_ARITY; nargs++) {
  442               for (int rcat = 0; rcat <= MAX_RCAT; rcat++) {
  443                   expandTemplate(template, true, rcat, nargs, 0, 0);
  444                   if (ALL_ARG_TYPES)  break;
  445                   expandTemplateForPrims(template, true, rcat, nargs, 1, 1);
  446                   if (ALL_RETURN_TYPES)  break;
  447               }
  448           }
  449       }
  450       static String catstr(int rcat, int nrefs, int nints, int nlongs) {
  451           int nargs = nrefs + nints + nlongs;
  452           String cat = TCHARS[rcat] + nargs;
  453           if (!ALL_ARG_TYPES)  cat += (nints==0?"":"I"+nints)+(nlongs==0?"":"J"+nlongs);
  454           return cat;
  455       }
  456       static void expandTemplateForPrims(String[] template, boolean topLevel, int rcat, int nargs, int minints, int minlongs) {
  457           for (int isLong = 0; isLong <= 1; isLong++) {
  458               for (int nprims = 1; nprims <= nargs; nprims++) {
  459                   int nrefs = nargs - nprims;
  460                   int nints = ((1-isLong) * nprims);
  461                   int nlongs = (isLong * nprims);
  462                   expandTemplate(template, topLevel, rcat, nrefs, nints, nlongs);
  463               }
  464           }
  465       }
  466       static void expandTemplate(String[] template, boolean topLevel,
  467                                  int rcat, int nrefs, int nints, int nlongs) {
  468           int nargs = nrefs + nints + nlongs;
  469           if (nrefs > MAX_REFS || nints > MAX_INTS || nlongs > MAX_LONGS)  return;
  470           VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
  471           if (topLevel && !done.add(VAR.cat.binding)) {
  472               System.out.println("    //repeat "+VAR.cat.binding);
  473               return;
  474           }
  475           for (int i = 0; i < template.length; i++) {
  476               String line = template[i];
  477               if (line.endsWith("@each-cat@")) {
  478                   // ignore
  479               } else if (line.endsWith("@each-R@")) {
  480                   int blockEnd = indexAfter(template, i, "@end-R@");
  481                   String[] block = stringsIn(template, i+1, blockEnd-1);
  482                   for (int rcat1 = rcat; rcat1 <= MAX_RCAT; rcat1++)
  483                       expandTemplate(block, false, rcat1, nrefs, nints, nlongs);
  484                   VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
  485                   i = blockEnd-1; continue;
  486               } else if (line.endsWith("@each-Tv@")) {
  487                   int blockEnd = indexAfter(template, i, "@end-Tv@");
  488                   String[] block = stringsIn(template, i+1, blockEnd-1);
  489                   expandTemplate(block, false, rcat, nrefs, nints, nlongs);
  490                   expandTemplateForPrims(block, false, rcat, nargs, nints+1, nlongs+1);
  491                   VAR.makeBindings(topLevel, rcat, nrefs, nints, nlongs);
  492                   i = blockEnd-1; continue;
  493               } else {
  494                   System.out.println(VAR.transform(line));
  495               }
  496           }
  497       }
  498   }
  499   //}}} */
  500   //params=[0, 10, 4, 99, 0, 0]
  501       static class A0 extends Adapter {
  502           protected A0(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  503           protected A0(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  504                           { super(e, i, c, t); }
  505           protected A0 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  506                           { return new A0(e, i, c, t); }
  507           protected Object invoke_L0() throws Throwable { return convert_L((Object)invoker.invokeExact(target)); }
  508           protected Object invoke_I0() throws Throwable { return convert_I((int)   invoker.invokeExact(target)); }
  509           protected Object invoke_J0() throws Throwable { return convert_J((long)  invoker.invokeExact(target)); }
  510           protected Object invoke_F0() throws Throwable { return convert_F((float) invoker.invokeExact(target)); }
  511           protected Object invoke_D0() throws Throwable { return convert_D((double)invoker.invokeExact(target)); }
  512       }
  513       static class A1 extends Adapter {
  514           protected A1(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  515           protected A1(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  516                           { super(e, i, c, t); }
  517           protected A1 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  518                           { return new A1(e, i, c, t); }
  519           protected Object invoke_L1(Object a0) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0)); }
  520           protected Object invoke_I1(Object a0) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0)); }
  521           protected Object invoke_J1(Object a0) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0)); }
  522           protected Object invoke_F1(Object a0) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0)); }
  523           protected Object invoke_D1(Object a0) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0)); }
  524       }
  525       static class A2 extends Adapter {
  526           protected A2(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  527           protected A2(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  528                           { super(e, i, c, t); }
  529           protected A2 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  530                           { return new A2(e, i, c, t); }
  531           protected Object invoke_L2(Object a0, Object a1) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1)); }
  532           protected Object invoke_I2(Object a0, Object a1) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1)); }
  533           protected Object invoke_J2(Object a0, Object a1) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1)); }
  534           protected Object invoke_F2(Object a0, Object a1) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1)); }
  535           protected Object invoke_D2(Object a0, Object a1) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1)); }
  536       }
  537       static class A3 extends Adapter {
  538           protected A3(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  539           protected A3(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  540                           { super(e, i, c, t); }
  541           protected A3 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  542                           { return new A3(e, i, c, t); }
  543           protected Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2)); }
  544           protected Object invoke_I3(Object a0, Object a1, Object a2) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2)); }
  545           protected Object invoke_J3(Object a0, Object a1, Object a2) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2)); }
  546           protected Object invoke_F3(Object a0, Object a1, Object a2) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2)); }
  547           protected Object invoke_D3(Object a0, Object a1, Object a2) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2)); }
  548       }
  549       static class A4 extends Adapter {
  550           protected A4(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  551           protected A4(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  552                           { super(e, i, c, t); }
  553           protected A4 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  554                           { return new A4(e, i, c, t); }
  555           protected Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3)); }
  556           protected Object invoke_I4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3)); }
  557           protected Object invoke_J4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3)); }
  558           protected Object invoke_F4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3)); }
  559           protected Object invoke_D4(Object a0, Object a1, Object a2, Object a3) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3)); }
  560       }
  561       static class A5 extends Adapter {
  562           protected A5(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  563           protected A5(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  564                           { super(e, i, c, t); }
  565           protected A5 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  566                           { return new A5(e, i, c, t); }
  567           protected Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
  568           protected Object invoke_I5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
  569           protected Object invoke_J5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
  570           protected Object invoke_F5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
  571           protected Object invoke_D5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4)); }
  572       }
  573       static class A6 extends Adapter {
  574           protected A6(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  575           protected A6(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  576                           { super(e, i, c, t); }
  577           protected A6 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  578                           { return new A6(e, i, c, t); }
  579           protected Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
  580           protected Object invoke_I6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
  581           protected Object invoke_J6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
  582           protected Object invoke_F6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
  583           protected Object invoke_D6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5)); }
  584       }
  585       static class A7 extends Adapter {
  586           protected A7(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  587           protected A7(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  588                           { super(e, i, c, t); }
  589           protected A7 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  590                           { return new A7(e, i, c, t); }
  591           protected Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
  592           protected Object invoke_I7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
  593           protected Object invoke_J7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
  594           protected Object invoke_F7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
  595           protected Object invoke_D7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6)); }
  596       }
  597       static class A8 extends Adapter {
  598           protected A8(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  599           protected A8(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  600                           { super(e, i, c, t); }
  601           protected A8 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  602                           { return new A8(e, i, c, t); }
  603           protected Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
  604           protected Object invoke_I8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
  605           protected Object invoke_J8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
  606           protected Object invoke_F8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
  607           protected Object invoke_D8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7)); }
  608       }
  609       static class A9 extends Adapter {
  610           protected A9(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  611           protected A9(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  612                           { super(e, i, c, t); }
  613           protected A9 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  614                           { return new A9(e, i, c, t); }
  615           protected Object invoke_L9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
  616           protected Object invoke_I9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
  617           protected Object invoke_J9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
  618           protected Object invoke_F9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
  619           protected Object invoke_D9(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8)); }
  620       }
  621       static class A10 extends Adapter {
  622           protected A10(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype
  623           protected A10(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  624                           { super(e, i, c, t); }
  625           protected A10 makeInstance(MethodHandle e, MethodHandle i, MethodHandle c, MethodHandle t)
  626                           { return new A10(e, i, c, t); }
  627           protected Object invoke_L10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_L((Object)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
  628           protected Object invoke_I10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_I((int)   invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
  629           protected Object invoke_J10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_J((long)  invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
  630           protected Object invoke_F10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_F((float) invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
  631           protected Object invoke_D10(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) throws Throwable { return convert_D((double)invoker.invokeExact(target, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)); }
  632       }
  633   }

Home » openjdk-7 » java.lang.invoke » [javadoc | source]