Mercurial > jdk8-mips64-public > nashorn / file revision

 /*

  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 package jdk.nashorn.internal.runtime.linker;

 import static jdk.nashorn.internal.runtime.linker.Lookup.MH;

 import java.lang.invoke.MethodHandle;

 import java.lang.invoke.MethodHandles;

 import jdk.nashorn.internal.runtime.ConsString;

 import jdk.nashorn.internal.runtime.Context;

 import jdk.nashorn.internal.runtime.GlobalObject;

 import jdk.nashorn.internal.runtime.ScriptFunction;

 import jdk.nashorn.internal.runtime.ScriptObject;

 import jdk.nashorn.internal.runtime.Undefined;

 import org.dynalang.dynalink.CallSiteDescriptor;

 import org.dynalang.dynalink.linker.ConversionComparator;

 import org.dynalang.dynalink.linker.GuardedInvocation;

 import org.dynalang.dynalink.linker.GuardingTypeConverterFactory;

 import org.dynalang.dynalink.linker.LinkRequest;

 import org.dynalang.dynalink.linker.LinkerServices;

 import org.dynalang.dynalink.linker.TypeBasedGuardingDynamicLinker;

 import org.dynalang.dynalink.support.Guards;

 /**

  * This is the main dynamic linker for Nashorn. It is used for linking all {@link ScriptObject} and its subclasses (this

  * includes {@link ScriptFunction} and its subclasses) as well as {@link Undefined}. This linker is exported to other

  * language runtimes by being declared in {@code META-INF/services/org.dynalang.dynalink.linker.GuardingDynamicLinker}

  * file of Nashorn's distribution.

  */

 public class NashornLinker implements TypeBasedGuardingDynamicLinker, GuardingTypeConverterFactory, ConversionComparator {

     /**

      * Returns true if {@code ScriptObject} is assignable from {@code type}, or it is {@code Undefined}.

      */

     @Override

     public boolean canLinkType(final Class<?> type) {

         return canLinkTypeStatic(type);

     }

     static boolean canLinkTypeStatic(final Class<?> type) {

         return ScriptObject.class.isAssignableFrom(type) || Undefined.class == type;

     }

     @Override

     public GuardedInvocation getGuardedInvocation(final LinkRequest request, final LinkerServices linkerServices) throws Exception {

         final LinkRequest requestWithoutContext = request.withoutRuntimeContext(); // Nashorn has no runtime context

         final Object self = requestWithoutContext.getReceiver();

         final CallSiteDescriptor desc = requestWithoutContext.getCallSiteDescriptor();

         if (desc.getNameTokenCount() < 2 || !"dyn".equals(desc.getNameToken(CallSiteDescriptor.SCHEME))) {

             // We only support standard "dyn:*[:*]" operations

             return null;

         }

         GuardedInvocation inv;

         if (self instanceof ScriptObject) {

             inv = ((ScriptObject)self).lookup(desc, request.isCallSiteUnstable());

             if (self instanceof ScriptFunction && "call".equals(desc.getNameToken(CallSiteDescriptor.OPERATOR))) {

                 // Add toObject wrapper for non-object self argument to non-strict functions

                 assert request.getArguments().length >= 2 : "No self argument in script function callsite";

                 Object thisObject = request.getArguments()[1];

                 // Add wrapper filter for primitive this-object on non-strict functions

                 if (NashornGuardedInvocation.isNonStrict(inv) && isPrimitive(thisObject)) {

                     MethodHandle wrapFilter = ((GlobalObject) Context.getGlobal()).getWrapFilter(thisObject);

                     MethodHandle invocation = MH.filterArguments(inv.getInvocation(), 1,

                             MH.asType(wrapFilter, wrapFilter.type().changeReturnType(Object.class)));

                     inv = new GuardedInvocation(invocation, inv.getSwitchPoint(), inv.getGuard());

                 }

             }

         } else if (self instanceof Undefined) {

             inv = Undefined.lookup(desc);

         } else {

             throw new AssertionError(); // Should never reach here.

         }

         return Bootstrap.asType(inv, linkerServices, desc);

     }

     @Override

     public GuardedInvocation convertToType(final Class<?> sourceType, final Class<?> targetType) throws Exception {

         final GuardedInvocation gi = convertToTypeNoCast(sourceType, targetType);

         return gi == null ? null : gi.asType(MH.type(targetType, sourceType));

     }

     /**

      * Main part of the implementation of {@link GuardingTypeConverterFactory#convertToType(Class, Class)} that doesn't

      * care about adapting the method signature; that's done by the invoking method. Returns either a built-in

      * conversion to primitive (or primitive wrapper) Java types or to String, or a just-in-time generated converter to

      * a SAM type (if the target type is a SAM type).

      * @param sourceType the source type

      * @param targetType the target type

      * @return a guarded invocation that converts from the source type to the target type.

      * @throws Exception if something goes wrong

      */

     private static GuardedInvocation convertToTypeNoCast(final Class<?> sourceType, final Class<?> targetType) throws Exception {

         final MethodHandle mh = JavaArgumentConverters.getConverter(targetType);

         if (mh != null) {

             return new GuardedInvocation(mh, canLinkTypeStatic(sourceType) ? null : IS_NASHORN_OR_UNDEFINED_TYPE);

         }

         return getSamTypeConverter(sourceType, targetType);

     }

     /**

      * Returns a guarded invocation that converts from a source type that is ScriptFunction, or a subclass or a

      * superclass of it) to a SAM type.

      * @param sourceType the source type (presumably ScriptFunction or a subclass or a superclass of it)

      * @param targetType the target type (presumably a SAM type)

      * @return a guarded invocation that converts from the source type to the target SAM type. null is returned if

      * either the source type is neither ScriptFunction, nor a subclass, nor a superclass of it, or if the target type

      * is not a SAM type.

      * @throws Exception if something goes wrong; generally, if there's an issue with creation of the SAM proxy type

      * constructor.

      */

     private static GuardedInvocation getSamTypeConverter(final Class<?> sourceType, final Class<?> targetType) throws Exception {

         // If source type is more generic than ScriptFunction class, we'll need to use a guard

         final boolean isSourceTypeGeneric = sourceType.isAssignableFrom(ScriptFunction.class);

         if ((isSourceTypeGeneric || ScriptFunction.class.isAssignableFrom(sourceType)) && isAutoConvertibleFromFunction(targetType)) {

             final MethodHandle ctor = JavaAdapterFactory.getConstructor(ScriptFunction.class, targetType);

             assert ctor != null; // if isAutoConvertibleFromFunction() returned true, then ctor must exist.

             return new GuardedInvocation(ctor, isSourceTypeGeneric ? IS_SCRIPT_FUNCTION : null);

         }

         return null;

     }

     private static boolean isAutoConvertibleFromFunction(final Class<?> clazz) {

         return JavaAdapterFactory.isAbstractClass(clazz) && !ScriptObject.class.isAssignableFrom(clazz) &&

                 JavaAdapterFactory.isAutoConvertibleFromFunction(clazz);

     }

     private static boolean isPrimitive(Object obj) {

         return obj instanceof Boolean ||

                obj instanceof Number ||

                obj instanceof String ||

                obj instanceof ConsString;

     }

     @Override

     public Comparison compareConversion(final Class<?> sourceType, final Class<?> targetType1, final Class<?> targetType2) {

         if(ScriptObject.class.isAssignableFrom(sourceType)) {

             if(targetType1.isInterface()) {

                 if(!targetType2.isInterface()) {

                     return Comparison.TYPE_1_BETTER;

                 }

             } else if(targetType2.isInterface()) {

                 return Comparison.TYPE_2_BETTER;

             }

         }

         return Comparison.INDETERMINATE;

     }

     private static final MethodHandle IS_SCRIPT_FUNCTION = Guards.isInstance(ScriptFunction.class, MH.type(Boolean.TYPE, Object.class));

     private static final MethodHandle IS_NASHORN_OR_UNDEFINED_TYPE = findOwnMH("isNashornTypeOrUndefined",

             Boolean.TYPE, Object.class);

     @SuppressWarnings("unused")

     private static boolean isNashornTypeOrUndefined(final Object obj) {

         return obj instanceof ScriptObject || obj instanceof Undefined;

     }

     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {

         return MH.findStatic(MethodHandles.lookup(), NashornLinker.class, name, MH.type(rtype, types));

     }

 }