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.objects;
  27 
  28 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
  29 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
  30 import static jdk.nashorn.internal.lookup.Lookup.MH;
  31 
  32 import java.lang.invoke.MethodHandle;
  33 import java.lang.invoke.MethodHandles;
  34 import java.lang.invoke.MethodType;
  35 import java.util.ArrayList;
  36 import java.util.Iterator;
  37 import java.util.List;
  38 import jdk.internal.dynalink.CallSiteDescriptor;
  39 import jdk.internal.dynalink.linker.GuardedInvocation;
  40 import jdk.internal.dynalink.linker.LinkRequest;
  41 import jdk.nashorn.internal.objects.annotations.Constructor;
  42 import jdk.nashorn.internal.objects.annotations.ScriptClass;
  43 import jdk.nashorn.internal.runtime.FindProperty;
  44 import jdk.nashorn.internal.runtime.JSType;
  45 import jdk.nashorn.internal.runtime.PropertyMap;
  46 import jdk.nashorn.internal.runtime.ScriptFunction;
  47 import jdk.nashorn.internal.runtime.ScriptObject;
  48 import jdk.nashorn.internal.runtime.ScriptRuntime;
  49 import jdk.nashorn.internal.runtime.arrays.ArrayLikeIterator;
  50 import jdk.nashorn.internal.lookup.Lookup;
  51 import jdk.nashorn.internal.scripts.JO;
  52 
  53 /**
  54  * This class is the implementation of the Nashorn-specific global object named {@code JSAdapter}. It can be
  55  * thought of as the {@link java.lang.reflect.Proxy} equivalent for JavaScript. NativeJSAdapter calls specially named
  56  * JavaScript methods on an adaptee object when property access/update/call/new/delete is attempted on it. Example:
  57  *<pre>
  58  *    var y = {
  59  *                __get__    : function (name) { ... }
  60  *                __has__    : function (name) { ... }
  61  *                __put__    : function (name, value) {...}
  62  *                __call__   : function (name, arg1, arg2) {...}
  63  *                __new__    : function (arg1, arg2) {...}
  64  *                __delete__ : function (name) { ... }
  65  *                __getIds__ : function () { ... }
  66  *            };
  67  *
  68  *    var x = new JSAdapter(y);
  69  *
  70  *    x.i;                        // calls y.__get__
  71  *    x.foo();                    // calls y.__call__
  72  *    new x();                    // calls y.__new__
  73  *    i in x;                     // calls y.__has__
  74  *    x.p = 10;                   // calls y.__put__
  75  *    delete x.p;                 // calls y.__delete__
  76  *    for (i in x) { print(i); }  // calls y.__getIds__
  77  * </pre>
  78  * <p>
  79  * JavaScript caller of adapter object is isolated from the fact that the property access/mutation/deletion are really
  80  * calls to JavaScript methods on adaptee.
  81  * </p>
  82  * <p>
  83  * JSAdapter constructor can optionally receive an "overrides" object. Properties of overrides object is copied to
  84  * JSAdapter instance. When user accessed property is one of these, then adaptee's methods like {@code __get__},
  85  * {@code __put__} etc. are not called for those. This can be used to make certain "preferred" properties that can be
  86  * accessed in the usual/faster way avoiding proxy mechanism. Example:
  87  * </p>
  88  * <pre>
  89  *     var x = new JSAdapter({ foo: 444, bar: 6546 }) {
  90  *          __get__: function(name) { return name; }
  91  *      };
  92  *
  93  *     x.foo;           // 444 directly retrieved without __get__ call
  94  *     x.bar = 'hello'; // "bar" directly set without __put__ call
  95  *     x.prop           // calls __get__("prop") as 'prop' is not overridden
  96  * </pre>
  97  * It is possible to pass a specific prototype for JSAdapter instance by passing three arguments to JSAdapter
  98  * constructor. So exact signature of JSAdapter constructor is as follows:
  99  * <pre>
 100  *     JSAdapter([proto], [overrides], adaptee);
 101  * </pre>
 102  * Both proto and overrides are optional - but adaptee is not. When proto is not passed {@code JSAdapter.prototype} is
 103  * used.
 104  */
 105 @ScriptClass("JSAdapter")
 106 public final class NativeJSAdapter extends ScriptObject {
 107     /** object get operation */
 108     public static final String __get__       = "__get__";
 109     /** object out operation */
 110     public static final String __put__       = "__put__";
 111     /** object call operation */
 112     public static final String __call__      = "__call__";
 113     /** object new operation */
 114     public static final String __new__       = "__new__";
 115     /** object getIds operation */
 116     public static final String __getIds__    = "__getIds__";
 117     /** object getKeys operation */
 118     public static final String __getKeys__   = "__getKeys__";
 119     /** object getValues operation */
 120     public static final String __getValues__ = "__getValues__";
 121     /** object has operation */
 122     public static final String __has__       = "__has__";
 123     /** object delete operation */
 124     public static final String __delete__    = "__delete__";
 125 
 126     // the new extensibility, sealing and freezing operations
 127 
 128     /** prevent extensions operation */
 129     public static final String __preventExtensions__ = "__preventExtensions__";
 130     /** isExtensible extensions operation */
 131     public static final String __isExtensible__      = "__isExtensible__";
 132     /** seal operation */
 133     public static final String __seal__              = "__seal__";
 134     /** isSealed extensions operation */
 135     public static final String __isSealed__          = "__isSealed__";
 136     /** freeze operation */
 137     public static final String __freeze__            = "__freeze__";
 138     /** isFrozen extensions operation */
 139     public static final String __isFrozen__          = "__isFrozen__";
 140 
 141     private final ScriptObject adaptee;
 142     private final boolean overrides;
 143 
 144     private static final MethodHandle IS_JSADAPTOR = findOwnMH("isJSAdaptor", boolean.class, Object.class, Object.class, MethodHandle.class, Object.class, ScriptFunction.class);
 145 
 146     // initialized by nasgen
 147     private static PropertyMap $nasgenmap$;
 148 
 149     static PropertyMap getInitialMap() {
 150         return $nasgenmap$;
 151     }
 152 
 153     NativeJSAdapter(final Object overrides, final ScriptObject adaptee, final ScriptObject proto, final PropertyMap map) {
 154         super(proto, map);
 155         this.adaptee = wrapAdaptee(adaptee);
 156         if (overrides instanceof ScriptObject) {
 157             this.overrides = true;
 158             final ScriptObject sobj = (ScriptObject)overrides;
 159             this.addBoundProperties(sobj);
 160         } else {
 161             this.overrides = false;
 162         }
 163     }
 164 
 165     private static ScriptObject wrapAdaptee(final ScriptObject adaptee) {
 166         return new JO(adaptee, JO.getInitialMap());
 167     }
 168 
 169     @Override
 170     public String getClassName() {
 171         return "JSAdapter";
 172     }
 173 
 174     @Override
 175     public int getInt(final Object key) {
 176         return (overrides && super.hasOwnProperty(key)) ? super.getInt(key) : callAdapteeInt(__get__, key);
 177     }
 178 
 179     @Override
 180     public int getInt(final double key) {
 181         return (overrides && super.hasOwnProperty(key)) ? super.getInt(key) : callAdapteeInt(__get__, key);
 182     }
 183 
 184     @Override
 185     public int getInt(final long key) {
 186         return (overrides && super.hasOwnProperty(key)) ? super.getInt(key) : callAdapteeInt(__get__, key);
 187     }
 188 
 189     @Override
 190     public int getInt(final int key) {
 191         return (overrides && super.hasOwnProperty(key)) ? super.getInt(key) : callAdapteeInt(__get__, key);
 192     }
 193 
 194     @Override
 195     public long getLong(final Object key) {
 196         return (overrides && super.hasOwnProperty(key)) ? super.getLong(key) : callAdapteeLong(__get__, key);
 197     }
 198 
 199     @Override
 200     public long getLong(final double key) {
 201         return (overrides && super.hasOwnProperty(key)) ? super.getLong(key) : callAdapteeLong(__get__, key);
 202     }
 203 
 204     @Override
 205     public long getLong(final long key) {
 206         return (overrides && super.hasOwnProperty(key)) ? super.getLong(key) : callAdapteeLong(__get__, key);
 207     }
 208 
 209     @Override
 210     public long getLong(final int key) {
 211         return (overrides && super.hasOwnProperty(key)) ? super.getLong(key) : callAdapteeLong(__get__, key);
 212     }
 213 
 214     @Override
 215     public double getDouble(final Object key) {
 216         return (overrides && super.hasOwnProperty(key)) ? super.getDouble(key) : callAdapteeDouble(__get__, key);
 217     }
 218 
 219     @Override
 220     public double getDouble(final double key) {
 221         return (overrides && super.hasOwnProperty(key)) ? super.getDouble(key) : callAdapteeDouble(__get__, key);
 222     }
 223 
 224     @Override
 225     public double getDouble(final long key) {
 226         return (overrides && super.hasOwnProperty(key)) ? super.getDouble(key) : callAdapteeDouble(__get__, key);
 227     }
 228 
 229     @Override
 230     public double getDouble(final int key) {
 231         return (overrides && super.hasOwnProperty(key)) ? super.getDouble(key) : callAdapteeDouble(__get__, key);
 232     }
 233 
 234     @Override
 235     public Object get(final Object key) {
 236         return (overrides && super.hasOwnProperty(key)) ? super.get(key) : callAdaptee(__get__, key);
 237     }
 238 
 239     @Override
 240     public Object get(final double key) {
 241         return (overrides && super.hasOwnProperty(key)) ? super.get(key) : callAdaptee(__get__, key);
 242     }
 243 
 244     @Override
 245     public Object get(final long key) {
 246         return (overrides && super.hasOwnProperty(key)) ? super.get(key) : callAdaptee(__get__, key);
 247     }
 248 
 249     @Override
 250     public Object get(final int key) {
 251         return (overrides && super.hasOwnProperty(key)) ? super.get(key) : callAdaptee(__get__, key);
 252     }
 253 
 254     @Override
 255     public void set(final Object key, final int value, final boolean strict) {
 256         if (overrides && super.hasOwnProperty(key)) {
 257             super.set(key, value, strict);
 258         } else {
 259             callAdaptee(__put__, key, value, strict);
 260         }
 261     }
 262 
 263     @Override
 264     public void set(final Object key, final long value, final boolean strict) {
 265         if (overrides && super.hasOwnProperty(key)) {
 266             super.set(key, value, strict);
 267         } else {
 268             callAdaptee(__put__, key, value, strict);
 269         }
 270     }
 271 
 272     @Override
 273     public void set(final Object key, final double value, final boolean strict) {
 274         if (overrides && super.hasOwnProperty(key)) {
 275             super.set(key, value, strict);
 276         } else {
 277             callAdaptee(__put__, key, value, strict);
 278         }
 279     }
 280 
 281     @Override
 282     public void set(final Object key, final Object value, final boolean strict) {
 283         if (overrides && super.hasOwnProperty(key)) {
 284             super.set(key, value, strict);
 285         } else {
 286             callAdaptee(__put__, key, value, strict);
 287         }
 288     }
 289 
 290     @Override
 291     public void set(final double key, final int value, final boolean strict) {
 292         if (overrides && super.hasOwnProperty(key)) {
 293             super.set(key, value, strict);
 294         } else {
 295             callAdaptee(__put__, key, value, strict);
 296         }
 297     }
 298 
 299     @Override
 300     public void set(final double key, final long value, final boolean strict) {
 301         if (overrides && super.hasOwnProperty(key)) {
 302             super.set(key, value, strict);
 303         } else {
 304             callAdaptee(__put__, key, value, strict);
 305         }
 306     }
 307 
 308     @Override
 309     public void set(final double key, final double value, final boolean strict) {
 310         if (overrides && super.hasOwnProperty(key)) {
 311             super.set(key, value, strict);
 312         } else {
 313             callAdaptee(__put__, key, value, strict);
 314         }
 315     }
 316 
 317     @Override
 318     public void set(final double key, final Object value, final boolean strict) {
 319         if (overrides && super.hasOwnProperty(key)) {
 320             super.set(key, value, strict);
 321         } else {
 322             callAdaptee(__put__, key, value, strict);
 323         }
 324     }
 325 
 326     @Override
 327     public void set(final long key, final int value, final boolean strict) {
 328         if (overrides && super.hasOwnProperty(key)) {
 329             super.set(key, value, strict);
 330         } else {
 331             callAdaptee(__put__, key, value, strict);
 332         }
 333     }
 334 
 335     @Override
 336     public void set(final long key, final long value, final boolean strict) {
 337         if (overrides && super.hasOwnProperty(key)) {
 338             super.set(key, value, strict);
 339         } else {
 340             callAdaptee(__put__, key, value, strict);
 341         }
 342     }
 343 
 344     @Override
 345     public void set(final long key, final double value, final boolean strict) {
 346         if (overrides && super.hasOwnProperty(key)) {
 347             super.set(key, value, strict);
 348         } else {
 349             callAdaptee(__put__, key, value, strict);
 350         }
 351     }
 352 
 353     @Override
 354     public void set(final long key, final Object value, final boolean strict) {
 355         if (overrides && super.hasOwnProperty(key)) {
 356             super.set(key, value, strict);
 357         } else {
 358             callAdaptee(__put__, key, value, strict);
 359         }
 360     }
 361 
 362     @Override
 363     public void set(final int key, final int value, final boolean strict) {
 364         if (overrides && super.hasOwnProperty(key)) {
 365             super.set(key, value, strict);
 366         } else {
 367             callAdaptee(__put__, key, value, strict);
 368         }
 369     }
 370 
 371     @Override
 372     public void set(final int key, final long value, final boolean strict) {
 373         if (overrides && super.hasOwnProperty(key)) {
 374             super.set(key, value, strict);
 375         } else {
 376             callAdaptee(__put__, key, value, strict);
 377         }
 378     }
 379 
 380     @Override
 381     public void set(final int key, final double value, final boolean strict) {
 382         if (overrides && super.hasOwnProperty(key)) {
 383             super.set(key, value, strict);
 384         } else {
 385             callAdaptee(__put__, key, value, strict);
 386         }
 387     }
 388 
 389     @Override
 390     public void set(final int key, final Object value, final boolean strict) {
 391         if (overrides && super.hasOwnProperty(key)) {
 392             super.set(key, value, strict);
 393         } else {
 394             callAdaptee(__put__, key, value, strict);
 395         }
 396     }
 397 
 398     @Override
 399     public boolean has(final Object key) {
 400         if (overrides && super.hasOwnProperty(key)) {
 401             return true;
 402         }
 403 
 404         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __has__, key));
 405     }
 406 
 407     @Override
 408     public boolean has(final int key) {
 409         if (overrides && super.hasOwnProperty(key)) {
 410             return true;
 411         }
 412 
 413         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __has__, key));
 414     }
 415 
 416     @Override
 417     public boolean has(final long key) {
 418         if (overrides && super.hasOwnProperty(key)) {
 419             return true;
 420         }
 421 
 422         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __has__, key));
 423     }
 424 
 425     @Override
 426     public boolean has(final double key) {
 427         if (overrides && super.hasOwnProperty(key)) {
 428             return true;
 429         }
 430 
 431         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __has__, key));
 432     }
 433 
 434     @Override
 435     public boolean delete(final int key, final boolean strict) {
 436         if (overrides && super.hasOwnProperty(key)) {
 437             return super.delete(key, strict);
 438         }
 439 
 440         return JSType.toBoolean(callAdaptee(Boolean.TRUE, __delete__, key, strict));
 441     }
 442 
 443     @Override
 444     public boolean delete(final long key, final boolean strict) {
 445         if (overrides && super.hasOwnProperty(key)) {
 446             return super.delete(key, strict);
 447         }
 448 
 449         return JSType.toBoolean(callAdaptee(Boolean.TRUE, __delete__, key, strict));
 450     }
 451 
 452     @Override
 453     public boolean delete(final double key, final boolean strict) {
 454         if (overrides && super.hasOwnProperty(key)) {
 455             return super.delete(key, strict);
 456         }
 457 
 458         return JSType.toBoolean(callAdaptee(Boolean.TRUE, __delete__, key, strict));
 459     }
 460 
 461     @Override
 462     public boolean delete(final Object key, final boolean strict) {
 463         if (overrides && super.hasOwnProperty(key)) {
 464             return super.delete(key, strict);
 465         }
 466 
 467         return JSType.toBoolean(callAdaptee(Boolean.TRUE, __delete__, key, strict));
 468     }
 469 
 470     @Override
 471     public Iterator<String> propertyIterator() {
 472         // Try __getIds__ first, if not found then try __getKeys__
 473         // In jdk6, we had added "__getIds__" so this is just for compatibility.
 474         Object func = adaptee.get(__getIds__);
 475         if (!(func instanceof ScriptFunction)) {
 476             func = adaptee.get(__getKeys__);
 477         }
 478 
 479         Object obj;
 480         if (func instanceof ScriptFunction) {
 481             obj = ScriptRuntime.apply((ScriptFunction)func, adaptee);
 482         } else {
 483             obj = new NativeArray(0);
 484         }
 485 
 486         final List<String> array = new ArrayList<>();
 487         for (final Iterator<Object> iter = ArrayLikeIterator.arrayLikeIterator(obj); iter.hasNext(); ) {
 488             array.add((String)iter.next());
 489         }
 490 
 491         return array.iterator();
 492     }
 493 
 494 
 495     @Override
 496     public Iterator<Object> valueIterator() {
 497         final Object obj = callAdaptee(new NativeArray(0), __getValues__);
 498         return ArrayLikeIterator.arrayLikeIterator(obj);
 499     }
 500 
 501     @Override
 502     public ScriptObject preventExtensions() {
 503         callAdaptee(__preventExtensions__);
 504         return this;
 505     }
 506 
 507     @Override
 508     public boolean isExtensible() {
 509         return JSType.toBoolean(callAdaptee(Boolean.TRUE, __isExtensible__));
 510     }
 511 
 512     @Override
 513     public ScriptObject seal() {
 514         callAdaptee(__seal__);
 515         return this;
 516     }
 517 
 518     @Override
 519     public boolean isSealed() {
 520         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __isSealed__));
 521     }
 522 
 523     @Override
 524     public ScriptObject freeze() {
 525         callAdaptee(__freeze__);
 526         return this;
 527     }
 528 
 529     @Override
 530     public boolean isFrozen() {
 531         return JSType.toBoolean(callAdaptee(Boolean.FALSE, __isFrozen__));
 532     }
 533 
 534     /**
 535      * Constructor
 536      *
 537      * @param isNew is this NativeJSAdapter instantiated with the new operator
 538      * @param self  self reference
 539      * @param args  arguments ([adaptee], [overrides, adaptee] or [proto, overrides, adaptee]
 540      * @return new NativeJSAdapter
 541      */
 542     @Constructor
 543     public static Object construct(final boolean isNew, final Object self, final Object... args) {
 544         Object proto     = UNDEFINED;
 545         Object overrides = UNDEFINED;
 546         Object adaptee;
 547 
 548         if (args == null || args.length == 0) {
 549             throw typeError("not.an.object", "null");
 550         }
 551 
 552         switch (args.length) {
 553         case 1:
 554             adaptee = args[0];
 555             break;
 556 
 557         case 2:
 558             overrides = args[0];
 559             adaptee   = args[1];
 560             break;
 561 
 562         default:
 563             //fallthru
 564         case 3:
 565             proto = args[0];
 566             overrides = args[1];
 567             adaptee = args[2];
 568             break;
 569         }
 570 
 571         if (!(adaptee instanceof ScriptObject)) {
 572             throw typeError("not.an.object", ScriptRuntime.safeToString(adaptee));
 573         }
 574 
 575         final Global global = Global.instance();
 576         if (proto != null && !(proto instanceof ScriptObject)) {
 577             proto = global.getJSAdapterPrototype();
 578         }
 579 
 580         return new NativeJSAdapter(overrides, (ScriptObject)adaptee, (ScriptObject)proto, getInitialMap());
 581     }
 582 
 583     @Override
 584     protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc) {
 585         return findHook(desc, __new__, false);
 586     }
 587 
 588     @Override
 589     protected GuardedInvocation findCallMethodMethod(final CallSiteDescriptor desc, final LinkRequest request) {
 590         if (overrides && super.hasOwnProperty(desc.getNameToken(2))) {
 591             try {
 592                 final GuardedInvocation inv = super.findCallMethodMethod(desc, request);
 593                 if (inv != null) {
 594                     return inv;
 595                 }
 596             } catch (final Exception e) {
 597                 //ignored
 598             }
 599         }
 600 
 601         return findHook(desc, __call__);
 602     }
 603 
 604     @Override
 605     protected GuardedInvocation findGetMethod(final CallSiteDescriptor desc, final LinkRequest request, final String operation) {
 606         final String name = desc.getNameToken(CallSiteDescriptor.NAME_OPERAND);
 607         if (overrides && super.hasOwnProperty(name)) {
 608             try {
 609                 final GuardedInvocation inv = super.findGetMethod(desc, request, operation);
 610                 if (inv != null) {
 611                     return inv;
 612                 }
 613             } catch (final Exception e) {
 614                 //ignored
 615             }
 616         }
 617 
 618         switch(operation) {
 619         case "getProp":
 620         case "getElem":
 621             return findHook(desc, __get__);
 622         case "getMethod":
 623             final FindProperty find = adaptee.findProperty(__call__, true);
 624             if (find != null) {
 625                 final Object value = find.getObjectValue();
 626                 if (value instanceof ScriptFunction) {
 627                     final ScriptFunctionImpl func = (ScriptFunctionImpl)value;
 628                     // TODO: It's a shame we need to produce a function bound to this and name, when we'd only need it bound
 629                     // to name. Probably not a big deal, but if we can ever make it leaner, it'd be nice.
 630                     return new GuardedInvocation(MH.dropArguments(MH.constant(Object.class,
 631                             func.makeBoundFunction(this, new Object[] { name })), 0, Object.class),
 632                             adaptee.getProtoSwitchPoint(__call__, find.getOwner()),
 633                             testJSAdaptor(adaptee, null, null, null));
 634                 }
 635             }
 636             throw typeError("no.such.function", desc.getNameToken(2), ScriptRuntime.safeToString(this));
 637         default:
 638             break;
 639         }
 640 
 641         throw new AssertionError("should not reach here");
 642     }
 643 
 644     @Override
 645     protected GuardedInvocation findSetMethod(final CallSiteDescriptor desc, final LinkRequest request) {
 646         if (overrides && super.hasOwnProperty(desc.getNameToken(CallSiteDescriptor.NAME_OPERAND))) {
 647             try {
 648                 final GuardedInvocation inv = super.findSetMethod(desc, request);
 649                 if (inv != null) {
 650                     return inv;
 651                 }
 652             } catch (final Exception e) {
 653                 //ignored
 654             }
 655         }
 656 
 657         return findHook(desc, __put__);
 658     }
 659 
 660     // -- Internals only below this point
 661     private Object callAdaptee(final String name, final Object... args) {
 662         return callAdaptee(UNDEFINED, name, args);
 663     }
 664 
 665     private double callAdapteeDouble(final String name, final Object... args) {
 666         return JSType.toNumber(callAdaptee(name, args));
 667     }
 668 
 669     private long callAdapteeLong(final String name, final Object... args) {
 670         return JSType.toLong(callAdaptee(name, args));
 671     }
 672 
 673     private int callAdapteeInt(final String name, final Object... args) {
 674         return JSType.toInt32(callAdaptee(name, args));
 675     }
 676 
 677     private Object callAdaptee(final Object retValue, final String name, final Object... args) {
 678         final Object func = adaptee.get(name);
 679         if (func instanceof ScriptFunction) {
 680             return ScriptRuntime.apply((ScriptFunction)func, adaptee, args);
 681         }
 682         return retValue;
 683     }
 684 
 685     private GuardedInvocation findHook(final CallSiteDescriptor desc, final String hook) {
 686         return findHook(desc, hook, true);
 687     }
 688 
 689     private GuardedInvocation findHook(final CallSiteDescriptor desc, final String hook, final boolean useName) {
 690         final FindProperty findData = adaptee.findProperty(hook, true);
 691         final MethodType type = desc.getMethodType();
 692         if (findData != null) {
 693             final String name = desc.getNameTokenCount() > 2 ? desc.getNameToken(2) : null;
 694             final Object value = findData.getObjectValue();
 695             if (value instanceof ScriptFunction) {
 696                 final ScriptFunction func = (ScriptFunction)value;
 697 
 698                 final MethodHandle methodHandle = getCallMethodHandle(findData, type,
 699                     useName ? name : null);
 700                 if (methodHandle != null) {
 701                     return new GuardedInvocation(
 702                             methodHandle,
 703                             adaptee.getProtoSwitchPoint(hook, findData.getOwner()),
 704                             testJSAdaptor(adaptee, findData.getGetter(Object.class), findData.getOwner(), func));
 705                 }
 706              }
 707         }
 708 
 709         switch (hook) {
 710         case __call__:
 711             throw typeError("no.such.function", desc.getNameToken(2), ScriptRuntime.safeToString(this));
 712         default:
 713             final MethodHandle methodHandle = hook.equals(__put__) ?
 714             MH.asType(Lookup.EMPTY_SETTER, type) :
 715             Lookup.emptyGetter(type.returnType());
 716             return new GuardedInvocation(methodHandle, adaptee.getProtoSwitchPoint(hook, null), testJSAdaptor(adaptee, null, null, null));
 717         }
 718     }
 719 
 720     private static MethodHandle testJSAdaptor(final Object adaptee, final MethodHandle getter, final Object where, final ScriptFunction func) {
 721         return MH.insertArguments(IS_JSADAPTOR, 1, adaptee, getter, where, func);
 722     }
 723 
 724     @SuppressWarnings("unused")
 725     private static boolean isJSAdaptor(final Object self, final Object adaptee, final MethodHandle getter, final Object where, final ScriptFunction func) {
 726         final boolean res = self instanceof NativeJSAdapter && ((NativeJSAdapter)self).getAdaptee() == adaptee;
 727         if (res && getter != null) {
 728             try {
 729                 return getter.invokeExact(where) == func;
 730             } catch (final RuntimeException | Error e) {
 731                 throw e;
 732             } catch (final Throwable t) {
 733                 throw new RuntimeException(t);
 734             }
 735         }
 736 
 737         return res;
 738     }
 739 
 740     /**
 741      * Get the adaptee
 742      * @return adaptee ScriptObject
 743      */
 744     public ScriptObject getAdaptee() {
 745         return adaptee;
 746     }
 747 
 748     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
 749         return MH.findStatic(MethodHandles.lookup(), NativeJSAdapter.class, name, MH.type(rtype, types));
 750     }
 751 }
--- EOF ---