1 /*
   2  * Copyright (c) 2010, 2013, 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 jdk.nashorn.internal.runtime;
  27 
  28 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
  29 import static jdk.nashorn.internal.lookup.Lookup.MH;
  30 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
  31 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
  32 
  33 import java.lang.invoke.MethodHandle;
  34 import java.lang.invoke.MethodHandles;
  35 import java.lang.invoke.MethodType;
  36 import jdk.internal.dynalink.CallSiteDescriptor;
  37 import jdk.internal.dynalink.linker.GuardedInvocation;
  38 import jdk.internal.dynalink.linker.LinkRequest;
  39 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
  40 import jdk.nashorn.internal.lookup.MethodHandleFactory;
  41 import jdk.nashorn.internal.objects.Global;
  42 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
  43 import jdk.nashorn.internal.runtime.linker.NashornGuards;
  44 
  45 /**
  46  * Runtime representation of a JavaScript function.
  47  */
  48 public abstract class ScriptFunction extends ScriptObject {
  49 
  50     /** Method handle for prototype getter for this ScriptFunction */
  51     public static final MethodHandle G$PROTOTYPE = findOwnMH("G$prototype", Object.class, Object.class);
  52 
  53     /** Method handle for prototype setter for this ScriptFunction */
  54     public static final MethodHandle S$PROTOTYPE = findOwnMH("S$prototype", void.class, Object.class, Object.class);
  55 
  56     /** Method handle for length getter for this ScriptFunction */
  57     public static final MethodHandle G$LENGTH = findOwnMH("G$length", int.class, Object.class);
  58 
  59     /** Method handle for name getter for this ScriptFunction */
  60     public static final MethodHandle G$NAME = findOwnMH("G$name", Object.class, Object.class);
  61 
  62     /** Method handle used for implementing sync() in mozilla_compat */
  63     public static final MethodHandle INVOKE_SYNC = findOwnMH("invokeSync", Object.class, ScriptFunction.class, Object.class, Object.class, Object[].class);
  64 
  65     /** Method handle for allocate function for this ScriptFunction */
  66     static final MethodHandle ALLOCATE = findOwnMH("allocate", Object.class);
  67 
  68     private static final MethodHandle WRAPFILTER = findOwnMH("wrapFilter", Object.class, Object.class);
  69 
  70     private static final MethodHandle GLOBALFILTER = findOwnMH("globalFilter", Object.class, Object.class);
  71 
  72     /** method handle to scope getter for this ScriptFunction */
  73     public static final Call GET_SCOPE = virtualCallNoLookup(ScriptFunction.class, "getScope", ScriptObject.class);
  74 
  75     private static final MethodHandle IS_FUNCTION_MH  = findOwnMH("isFunctionMH", boolean.class, Object.class, ScriptFunctionData.class);
  76 
  77     private static final MethodHandle IS_NONSTRICT_FUNCTION = findOwnMH("isNonStrictFunction", boolean.class, Object.class, Object.class, ScriptFunctionData.class);
  78 
  79     private static final MethodHandle ADD_ZEROTH_ELEMENT = findOwnMH("addZerothElement", Object[].class, Object[].class, Object.class);
  80 
  81     /** The parent scope. */
  82     private final ScriptObject scope;
  83 
  84     private final ScriptFunctionData data;
  85 
  86     /** The property map used for newly allocated object when function is used as constructor. */
  87     protected PropertyMap allocatorMap;
  88 
  89     /**
  90      * Constructor
  91      *
  92      * @param name          function name
  93      * @param methodHandle  method handle to function (if specializations are present, assumed to be most generic)
  94      * @param map           property map
  95      * @param scope         scope
  96      * @param specs         specialized version of this function - other method handles
  97      * @param flags         {@link ScriptFunctionData} flags
  98      */
  99     protected ScriptFunction(
 100             final String name,
 101             final MethodHandle methodHandle,
 102             final PropertyMap map,
 103             final ScriptObject scope,
 104             final MethodHandle[] specs,
 105             final int flags) {
 106 
 107         this(new FinalScriptFunctionData(name, methodHandle, specs, flags), map, scope);
 108     }
 109 
 110     /**
 111      * Constructor
 112      *
 113      * @param data          static function data
 114      * @param map           property map
 115      * @param scope         scope
 116      */
 117     protected ScriptFunction(
 118             final ScriptFunctionData data,
 119             final PropertyMap map,
 120             final ScriptObject scope) {
 121 
 122         super(map);
 123 
 124         if (Context.DEBUG) {
 125             constructorCount++;
 126         }
 127 
 128         this.data  = data;
 129         this.scope = scope;
 130         this.allocatorMap = data.getAllocatorMap();
 131     }
 132 
 133     @Override
 134     public String getClassName() {
 135         return "Function";
 136     }
 137 
 138     /**
 139      * ECMA 15.3.5.3 [[HasInstance]] (V)
 140      * Step 3 if "prototype" value is not an Object, throw TypeError
 141      */
 142     @Override
 143     public boolean isInstance(final ScriptObject instance) {
 144         final Object basePrototype = getTargetFunction().getPrototype();
 145         if (!(basePrototype instanceof ScriptObject)) {
 146             throw typeError("prototype.not.an.object", ScriptRuntime.safeToString(getTargetFunction()), ScriptRuntime.safeToString(basePrototype));
 147         }
 148 
 149         for (ScriptObject proto = instance.getProto(); proto != null; proto = proto.getProto()) {
 150             if (proto == basePrototype) {
 151                 return true;
 152             }
 153         }
 154 
 155         return false;
 156     }
 157 
 158     /**
 159      * Returns the target function for this function. If the function was not created using
 160      * {@link #makeBoundFunction(Object, Object[])}, its target function is itself. If it is bound, its target function
 161      * is the target function of the function it was made from (therefore, the target function is always the final,
 162      * unbound recipient of the calls).
 163      * @return the target function for this function.
 164      */
 165     protected ScriptFunction getTargetFunction() {
 166         return this;
 167     }
 168 
 169     boolean isBoundFunction() {
 170         return getTargetFunction() != this;
 171     }
 172 
 173     /**
 174      * Set the arity of this ScriptFunction
 175      * @param arity arity
 176      */
 177     public final void setArity(final int arity) {
 178         data.setArity(arity);
 179     }
 180 
 181     /**
 182      * Is this a ECMAScript 'use strict' function?
 183      * @return true if function is in strict mode
 184      */
 185     public boolean isStrict() {
 186         return data.isStrict();
 187     }
 188 
 189     /**
 190      * Returns true if this is a non-strict, non-built-in function that requires non-primitive this argument
 191      * according to ECMA 10.4.3.
 192      * @return true if this argument must be an object
 193      */
 194     public boolean needsWrappedThis() {
 195         return data.needsWrappedThis();
 196     }
 197 
 198     /**
 199      * Execute this script function.
 200      * @param self  Target object.
 201      * @param arguments  Call arguments.
 202      * @return ScriptFunction result.
 203      * @throws Throwable if there is an exception/error with the invocation or thrown from it
 204      */
 205     Object invoke(final Object self, final Object... arguments) throws Throwable {
 206         if (Context.DEBUG) {
 207             invokes++;
 208         }
 209         return data.invoke(this, self, arguments);
 210     }
 211 
 212     /**
 213      * Execute this script function as a constructor.
 214      * @param arguments  Call arguments.
 215      * @return Newly constructed result.
 216      * @throws Throwable if there is an exception/error with the invocation or thrown from it
 217      */
 218     Object construct(final Object... arguments) throws Throwable {
 219         return data.construct(this, arguments);
 220     }
 221 
 222     /**
 223      * Allocate function. Called from generated {@link ScriptObject} code
 224      * for allocation as a factory method
 225      *
 226      * @return a new instance of the {@link ScriptObject} whose allocator this is
 227      */
 228     @SuppressWarnings("unused")
 229     private Object allocate() {
 230         if (Context.DEBUG) {
 231             allocations++;
 232         }
 233         assert !isBoundFunction(); // allocate never invoked on bound functions
 234 
 235         final ScriptObject object = data.allocate(allocatorMap);
 236 
 237         if (object != null) {
 238             Object prototype = getPrototype();
 239             if (prototype instanceof ScriptObject) {
 240                 object.setInitialProto((ScriptObject)prototype);
 241             }
 242 
 243             if (object.getProto() == null) {
 244                 object.setInitialProto(getObjectPrototype());
 245             }
 246         }
 247 
 248         return object;
 249     }
 250 
 251     /**
 252      * Return Object.prototype - used by "allocate"
 253      * @return Object.prototype
 254      */
 255     protected abstract ScriptObject getObjectPrototype();
 256 
 257     /**
 258      * Creates a version of this function bound to a specific "self" and other arguments, as per
 259      * {@code Function.prototype.bind} functionality in ECMAScript 5.1 section 15.3.4.5.
 260      * @param self the self to bind to this function. Can be null (in which case, null is bound as this).
 261      * @param args additional arguments to bind to this function. Can be null or empty to not bind additional arguments.
 262      * @return a function with the specified self and parameters bound.
 263      */
 264     protected ScriptFunction makeBoundFunction(final Object self, final Object[] args) {
 265         return makeBoundFunction(data.makeBoundFunctionData(this, self, args));
 266     }
 267 
 268     /**
 269      * Create a version of this function as in {@link ScriptFunction#makeBoundFunction(Object, Object[])},
 270      * but using a {@link ScriptFunctionData} for the bound data.
 271      *
 272      * @param boundData ScriptFuntionData for the bound function
 273      * @return a function with the bindings performed according to the given data
 274      */
 275     protected abstract ScriptFunction makeBoundFunction(ScriptFunctionData boundData);
 276 
 277     @Override
 278     public final String safeToString() {
 279         return toSource();
 280     }
 281 
 282     @Override
 283     public String toString() {
 284         return data.toString();
 285     }
 286 
 287     /**
 288      * Get this function as a String containing its source code. If no source code
 289      * exists in this ScriptFunction, its contents will be displayed as {@code [native code]}
 290      * @return string representation of this function's source
 291      */
 292     public final String toSource() {
 293         return data.toSource();
 294     }
 295 
 296     /**
 297      * Get the prototype object for this function
 298      * @return prototype
 299      */
 300     public abstract Object getPrototype();
 301 
 302     /**
 303      * Set the prototype object for this function
 304      * @param prototype new prototype object
 305      */
 306     public abstract void setPrototype(Object prototype);
 307 
 308     /**
 309      * Create a function that invokes this function synchronized on {@code sync} or the self object
 310      * of the invocation.
 311      * @param sync the Object to synchronize on, or undefined
 312      * @return synchronized function
 313      */
 314     public abstract ScriptFunction makeSynchronizedFunction(Object sync);
 315 
 316     /**
 317      * Return the most appropriate invoke handle if there are specializations
 318      * @param type most specific method type to look for invocation with
 319      * @param args args for trampoline invocation
 320      * @return invoke method handle
 321      */
 322     private MethodHandle getBestInvoker(final MethodType type, final Object[] args) {
 323         return data.getBestInvoker(type, args);
 324     }
 325 
 326     /**
 327      * Return the most appropriate invoke handle if there are specializations
 328      * @param type most specific method type to look for invocation with
 329      * @return invoke method handle
 330      */
 331     public MethodHandle getBestInvoker(final MethodType type) {
 332         return getBestInvoker(type, null);
 333     }
 334 
 335     /**
 336      * Return the invoke handle bound to a given ScriptObject self reference.
 337      * If callee parameter is required result is rebound to this.
 338      *
 339      * @param self self reference
 340      * @return bound invoke handle
 341      */
 342     public final MethodHandle getBoundInvokeHandle(final Object self) {
 343         return MH.bindTo(bindToCalleeIfNeeded(data.getGenericInvoker()), self);
 344     }
 345 
 346     /**
 347      * Bind the method handle to this {@code ScriptFunction} instance if it needs a callee parameter. If this function's
 348      * method handles don't have a callee parameter, the handle is returned unchanged.
 349      * @param methodHandle the method handle to potentially bind to this function instance.
 350      * @return the potentially bound method handle
 351      */
 352     private MethodHandle bindToCalleeIfNeeded(final MethodHandle methodHandle) {
 353         return ScriptFunctionData.needsCallee(methodHandle) ? MH.bindTo(methodHandle, this) : methodHandle;
 354 
 355     }
 356 
 357     /**
 358      * Get the name for this function
 359      * @return the name
 360      */
 361     public final String getName() {
 362         return data.getName();
 363     }
 364 
 365 
 366     /**
 367      * Get the scope for this function
 368      * @return the scope
 369      */
 370     public final ScriptObject getScope() {
 371         return scope;
 372     }
 373 
 374     /**
 375      * Prototype getter for this ScriptFunction - follows the naming convention
 376      * used by Nasgen and the code generator
 377      *
 378      * @param self  self reference
 379      * @return self's prototype
 380      */
 381     public static Object G$prototype(final Object self) {
 382         return (self instanceof ScriptFunction) ?
 383             ((ScriptFunction)self).getPrototype() :
 384             UNDEFINED;
 385     }
 386 
 387     /**
 388      * Prototype setter for this ScriptFunction - follows the naming convention
 389      * used by Nasgen and the code generator
 390      *
 391      * @param self  self reference
 392      * @param prototype prototype to set
 393      */
 394     public static void S$prototype(final Object self, final Object prototype) {
 395         if (self instanceof ScriptFunction) {
 396             ((ScriptFunction)self).setPrototype(prototype);
 397         }
 398     }
 399 
 400     /**
 401      * Length getter - ECMA 15.3.3.2: Function.length
 402      * @param self self reference
 403      * @return length
 404      */
 405     public static int G$length(final Object self) {
 406         if (self instanceof ScriptFunction) {
 407             return ((ScriptFunction)self).data.getArity();
 408         }
 409 
 410         return 0;
 411     }
 412 
 413     /**
 414      * Name getter - ECMA Function.name
 415      * @param self self refence
 416      * @return the name, or undefined if none
 417      */
 418     public static Object G$name(final Object self) {
 419         if (self instanceof ScriptFunction) {
 420             return ((ScriptFunction)self).getName();
 421         }
 422 
 423         return UNDEFINED;
 424     }
 425 
 426     /**
 427      * Get the prototype for this ScriptFunction
 428      * @param constructor constructor
 429      * @return prototype, or null if given constructor is not a ScriptFunction
 430      */
 431     public static ScriptObject getPrototype(final Object constructor) {
 432         if (constructor instanceof ScriptFunction) {
 433             final Object proto = ((ScriptFunction)constructor).getPrototype();
 434             if (proto instanceof ScriptObject) {
 435                 return (ScriptObject)proto;
 436             }
 437         }
 438 
 439         return null;
 440     }
 441 
 442     // These counters are updated only in debug mode.
 443     private static int constructorCount;
 444     private static int invokes;
 445     private static int allocations;
 446 
 447     /**
 448      * @return the constructorCount
 449      */
 450     public static int getConstructorCount() {
 451         return constructorCount;
 452     }
 453 
 454     /**
 455      * @return the invokes
 456      */
 457     public static int getInvokes() {
 458         return invokes;
 459     }
 460 
 461     /**
 462      * @return the allocations
 463      */
 464     public static int getAllocations() {
 465         return allocations;
 466     }
 467 
 468     @Override
 469     protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc) {
 470         final MethodType type = desc.getMethodType();
 471         return new GuardedInvocation(pairArguments(data.getBestConstructor(type.changeParameterType(0, ScriptFunction.class), null), type), null, getFunctionGuard(this));
 472     }
 473 
 474     @SuppressWarnings("unused")
 475     private static Object wrapFilter(final Object obj) {
 476         if (obj instanceof ScriptObject || !ScriptFunctionData.isPrimitiveThis(obj)) {
 477             return obj;
 478         }
 479         return Context.getGlobal().wrapAsObject(obj);
 480     }
 481 
 482 
 483     @SuppressWarnings("unused")
 484     private static Object globalFilter(final Object object) {
 485         // replace whatever we get with the current global object
 486         return Context.getGlobal();
 487     }
 488 
 489     /**
 490      * dyn:call call site signature: (callee, thiz, [args...])
 491      * generated method signature:   (callee, thiz, [args...])
 492      *
 493      * cases:
 494      * (a) method has callee parameter
 495      *   (1) for local/scope calls, we just bind thiz and drop the second argument.
 496      *   (2) for normal this-calls, we have to swap thiz and callee to get matching signatures.
 497      * (b) method doesn't have callee parameter (builtin functions)
 498      *   (3) for local/scope calls, bind thiz and drop both callee and thiz.
 499      *   (4) for normal this-calls, drop callee.
 500      */
 501     @Override
 502     protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {
 503         final MethodType type = desc.getMethodType();
 504         final boolean scopeCall = NashornCallSiteDescriptor.isScope(desc);
 505 
 506         if (request.isCallSiteUnstable()) {
 507             // (callee, this, args...) => (callee, this, args[])
 508             final MethodHandle collector = MH.asCollector(ScriptRuntime.APPLY.methodHandle(), Object[].class, type.parameterCount() - 2);
 509 
 510             // If call site is statically typed to take a ScriptFunction, we don't need a guard, otherwise we need a
 511             // generic "is this a ScriptFunction?" guard.
 512             return new GuardedInvocation(collector, ScriptFunction.class.isAssignableFrom(desc.getMethodType().parameterType(0))
 513                     ? null : NashornGuards.getScriptFunctionGuard());
 514         }
 515 
 516         MethodHandle boundHandle;
 517         MethodHandle guard = null;
 518 
 519         if (data.needsCallee()) {
 520             final MethodHandle callHandle = getBestInvoker(type, request.getArguments());
 521             if (scopeCall && needsWrappedThis()) {
 522                 // Make a handle that drops the passed "this" argument and substitutes either Global or Undefined
 523                 // (callee, this, args...) => (callee, [this], args...)
 524                 boundHandle = MH.filterArguments(callHandle, 1, GLOBALFILTER);
 525             } else {
 526                 // It's already (callee, this, args...), just what we need
 527                 boundHandle = callHandle;
 528             }
 529         } else {
 530             final MethodHandle callHandle = getBestInvoker(type.dropParameterTypes(0, 1), request.getArguments());
 531             if (data.isBuiltin() && "extend".equals(data.getName())) {
 532                 // NOTE: the only built-in named "extend" is NativeJava.extend. As a special-case we're binding the
 533                 // current lookup as its "this" so it can do security-sensitive creation of adapter classes.
 534                 boundHandle = MH.dropArguments(MH.bindTo(callHandle, desc.getLookup()), 0, Object.class, Object.class);
 535             } else if (scopeCall && needsWrappedThis()) {
 536                 // Make a handle that drops the passed "this" argument and substitutes either Global or Undefined
 537                 // (this, args...) => ([this], args...)
 538                 boundHandle = MH.filterArguments(callHandle, 0, GLOBALFILTER);
 539                 // ([this], args...) => ([callee], [this], args...)
 540                 boundHandle = MH.dropArguments(boundHandle, 0, Object.class);
 541             } else {
 542                 // (this, args...) => ([callee], this, args...)
 543                 boundHandle = MH.dropArguments(callHandle, 0, Object.class);
 544             }
 545         }
 546 
 547         // For non-strict functions, check whether this-object is primitive type.
 548         // If so add a to-object-wrapper argument filter.
 549         // Else install a guard that will trigger a relink when the argument becomes primitive.
 550         if (!scopeCall && needsWrappedThis()) {
 551             if (ScriptFunctionData.isPrimitiveThis(request.getArguments()[1])) {
 552                 boundHandle = MH.filterArguments(boundHandle, 1, WRAPFILTER);
 553             } else {
 554                 guard = getNonStrictFunctionGuard(this);
 555             }
 556         }
 557 
 558         boundHandle = pairArguments(boundHandle, type);
 559 
 560         return new GuardedInvocation(boundHandle, guard == null ? getFunctionGuard(this) : guard);
 561    }
 562 
 563     /**
 564      * Used for noSuchMethod/noSuchProperty and JSAdapter hooks.
 565      *
 566      * These don't want a callee parameter, so bind that. Name binding is optional.
 567      */
 568     MethodHandle getCallMethodHandle(final MethodType type, final String bindName) {
 569         return pairArguments(bindToNameIfNeeded(bindToCalleeIfNeeded(getBestInvoker(type, null)), bindName), type);
 570     }
 571 
 572     private static MethodHandle bindToNameIfNeeded(final MethodHandle methodHandle, final String bindName) {
 573         if (bindName == null) {
 574             return methodHandle;
 575         }
 576 
 577         // if it is vararg method, we need to extend argument array with
 578         // a new zeroth element that is set to bindName value.
 579         final MethodType methodType = methodHandle.type();
 580         final int parameterCount = methodType.parameterCount();
 581         final boolean isVarArg = parameterCount > 0 && methodType.parameterType(parameterCount - 1).isArray();
 582 
 583         if (isVarArg) {
 584             return MH.filterArguments(methodHandle, 1, MH.insertArguments(ADD_ZEROTH_ELEMENT, 1, bindName));
 585         }
 586         return MH.insertArguments(methodHandle, 1, bindName);
 587     }
 588 
 589     /**
 590      * Get the guard that checks if a {@link ScriptFunction} is equal to
 591      * a known ScriptFunction, using reference comparison
 592      *
 593      * @param function The ScriptFunction to check against. This will be bound to the guard method handle
 594      *
 595      * @return method handle for guard
 596      */
 597     private static MethodHandle getFunctionGuard(final ScriptFunction function) {
 598         assert function.data != null;
 599         return MH.insertArguments(IS_FUNCTION_MH, 1, function.data);
 600     }
 601 
 602     /**
 603      * Get a guard that checks if a {@link ScriptFunction} is equal to
 604      * a known ScriptFunction using reference comparison, and whether the type of
 605      * the second argument (this-object) is not a JavaScript primitive type.
 606      *
 607      * @param function The ScriptFunction to check against. This will be bound to the guard method handle
 608      *
 609      * @return method handle for guard
 610      */
 611     private static MethodHandle getNonStrictFunctionGuard(final ScriptFunction function) {
 612         assert function.data != null;
 613         return MH.insertArguments(IS_NONSTRICT_FUNCTION, 2, function.data);
 614     }
 615 
 616     @SuppressWarnings("unused")
 617     private static boolean isFunctionMH(final Object self, final ScriptFunctionData data) {
 618         return self instanceof ScriptFunction && ((ScriptFunction)self).data == data;
 619     }
 620 
 621     @SuppressWarnings("unused")
 622     private static boolean isNonStrictFunction(final Object self, final Object arg, final ScriptFunctionData data) {
 623         return self instanceof ScriptFunction && ((ScriptFunction)self).data == data && arg instanceof ScriptObject;
 624     }
 625 
 626     @SuppressWarnings("unused")
 627     private static Object[] addZerothElement(final Object[] args, final Object value) {
 628         // extends input array with by adding new zeroth element
 629         final Object[] src = (args == null)? ScriptRuntime.EMPTY_ARRAY : args;
 630         final Object[] result = new Object[src.length + 1];
 631         System.arraycopy(src, 0, result, 1, src.length);
 632         result[0] = value;
 633         return result;
 634     }
 635 
 636     @SuppressWarnings("unused")
 637     private static Object invokeSync(final ScriptFunction func, final Object sync, final Object self, final Object... args)
 638             throws Throwable {
 639         final Object syncObj = sync == UNDEFINED ? self : sync;
 640         synchronized (syncObj) {
 641             return func.invoke(self, args);
 642         }
 643     }
 644 
 645     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
 646         final Class<?>   own = ScriptFunction.class;
 647         final MethodType mt  = MH.type(rtype, types);
 648         try {
 649             return MH.findStatic(MethodHandles.lookup(), own, name, mt);
 650         } catch (final MethodHandleFactory.LookupException e) {
 651             return MH.findVirtual(MethodHandles.lookup(), own, name, mt);
 652         }
 653     }
 654 }
 655 
--- EOF ---