jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/runtime/NativeJavaPackage.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/NativeJavaPackage.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/NativeJavaPackage.java

Thu, 24 May 2018 16:39:31 +0800

author: aoqi
date: Thu, 24 May 2018 16:39:31 +0800
changeset 1959: 61ffdd1b89f2
parent 1534: 7b64298633b2
parent 1205: 4112748288bb
permissions: -rw-r--r--

Merge

 /*
  * 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;
 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
 import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import jdk.internal.dynalink.CallSiteDescriptor;
 import jdk.internal.dynalink.beans.BeansLinker;
 import jdk.internal.dynalink.beans.StaticClass;
 import jdk.internal.dynalink.linker.GuardedInvocation;
 import jdk.internal.dynalink.linker.LinkRequest;
 import jdk.internal.dynalink.support.Guards;
 import jdk.nashorn.internal.lookup.MethodHandleFactory;
 import jdk.nashorn.internal.lookup.MethodHandleFunctionality;
 import jdk.nashorn.internal.objects.annotations.Attribute;
 import jdk.nashorn.internal.objects.annotations.Function;
 /**
  * An object that exposes Java packages and classes as its properties. Packages are exposed as objects that have further
  * sub-packages and classes as their properties. Normally, three instances of this class are exposed as built-in objects
  * in Nashorn: {@code "Packages"}, {@code "java"}, and {@code "javax"}. Typical usages are:
  * <pre>
  * var list = new java.util.ArrayList()
  * var sprocket = new Packages.com.acme.Sprocket()
  * </pre>
  * or you can store the type objects in a variable for later reuse:
  * <pre>
  * var ArrayList = java.util.ArrayList
  * var list = new ArrayList
  * </pre>
  * You can also use {@link jdk.nashorn.internal.objects.NativeJava#type(Object, Object)} to access Java classes. These two statements are mostly
  * equivalent:
  * <pre>
  * var listType1 = java.util.ArrayList
  * var listType2 = Java.type("java.util.ArrayList")
  * </pre>
  * The difference is that {@code Java.type()} will throw an error if the class does not exist, while the first
  * expression will return an empty object, as it must treat all non-existent classes as potentially being further
  * subpackages. As such, {@code Java.type()} has the potential to catch typos earlier. A further difference is that
  * {@code Java.type()} doesn't recognize {@code .} (dot) as the separator between outer class name and inner class name,
  * it only recognizes the dollar sign. These are equivalent:
  * <pre>
  * var ftype1 = java.awt.geom.Arc2D$Float
  * var ftype2 = java.awt.geom.Arc2D.Float
  * var ftype3 = Java.asType("java.awt.geom.Arc2D$Float")
  * var ftype4 = Java.asType("java.awt.geom.Arc2D").Float
  * </pre>
  */
 public final class NativeJavaPackage extends ScriptObject {
     private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();
     private static final MethodHandle CLASS_NOT_FOUND = findOwnMH("classNotFound", Void.TYPE, NativeJavaPackage.class);
     private static final MethodHandle TYPE_GUARD = Guards.getClassGuard(NativeJavaPackage.class);
     /** Full name of package (includes path.) */
     private final String name;
     /**
      * Public constructor to be accessible from {@link jdk.nashorn.internal.objects.Global}
      * @param name  package name
      * @param proto proto
      */
     public NativeJavaPackage(final String name, final ScriptObject proto) {
         super(proto, null);
         // defense-in-path, check here for sensitive packages
         Context.checkPackageAccess(name);
         this.name = name;
     }
     @Override
     public String getClassName() {
         return "JavaPackage";
     }
     @Override
     public boolean equals(final Object other) {
         if (other instanceof NativeJavaPackage) {
             return name.equals(((NativeJavaPackage)other).name);
         }
         return false;
     }
     @Override
     public int hashCode() {
         return name == null ? 0 : name.hashCode();
     }
     /**
      * Get the full name of the package
      * @return the name
      */
     public String getName() {
         return name;
     }
     @Override
     public String safeToString() {
         return toString();
     }
     @Override
     public String toString() {
         return "[JavaPackage " + name + "]";
     }
     @Override
     public Object getDefaultValue(final Class<?> hint) {
         if (hint == String.class) {
             return toString();
         }
         return super.getDefaultValue(hint);
     }
     @Override
     protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc, final LinkRequest request) {
         return createClassNotFoundInvocation(desc);
     }
     @Override
     protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {
         return createClassNotFoundInvocation(desc);
     }
     private static GuardedInvocation createClassNotFoundInvocation(final CallSiteDescriptor desc) {
         // If NativeJavaPackage is invoked either as a constructor or as a function, throw a ClassNotFoundException as
         // we can assume the user attempted to instantiate a non-existent class.
         final MethodType type = desc.getMethodType();
         return new GuardedInvocation(
                 MH.dropArguments(CLASS_NOT_FOUND, 1, type.parameterList().subList(1, type.parameterCount())),
                 type.parameterType(0) == NativeJavaPackage.class ? null : TYPE_GUARD);
     }
     @SuppressWarnings("unused")
     private static void classNotFound(final NativeJavaPackage pkg) throws ClassNotFoundException {
         throw new ClassNotFoundException(pkg.name);
     }
     /**
      * "No such property" call placeholder.
      *
      * This can never be called as we override {@link ScriptObject#noSuchProperty}. We do declare it here as it's a signal
      * to {@link WithObject} that it's worth trying doing a {@code noSuchProperty} on this object.
      *
      * @param self self reference
      * @param name property name
      * @return never returns
      */
     @Function(attributes = Attribute.NOT_ENUMERABLE)
     public static Object __noSuchProperty__(final Object self, final Object name) {
         throw new AssertionError("__noSuchProperty__ placeholder called");
     }
     /**
      * "No such method call" placeholder
      *
      * This can never be called as we override {@link ScriptObject#noSuchMethod}. We do declare it here as it's a signal
      * to {@link WithObject} that it's worth trying doing a noSuchProperty on this object.
      *
      * @param self self reference
      * @param args arguments to method
      * @return never returns
      */
     @Function(attributes = Attribute.NOT_ENUMERABLE)
     public static Object __noSuchMethod__(final Object self, final Object... args) {
         throw new AssertionError("__noSuchMethod__ placeholder called");
     }
     /**
      * Handle creation of new attribute.
      * @param desc the call site descriptor
      * @param request the link request
      * @return Link to be invoked at call site.
      */
     @Override
     public GuardedInvocation noSuchProperty(final CallSiteDescriptor desc, final LinkRequest request) {
         final String propertyName = desc.getNameToken(2);
         createProperty(propertyName);
         return super.lookup(desc, request);
     }
     @Override
     protected Object invokeNoSuchProperty(final String key, final boolean isScope, final int programPoint) {
         final Object retval = createProperty(key);
         if (isValid(programPoint)) {
             throw new UnwarrantedOptimismException(retval, programPoint);
         }
         return retval;
     }
     @Override
     public GuardedInvocation noSuchMethod(final CallSiteDescriptor desc, final LinkRequest request) {
         return noSuchProperty(desc, request);
     }
     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
         return MH.findStatic(MethodHandles.lookup(), NativeJavaPackage.class, name, MH.type(rtype, types));
     }
     private Object createProperty(final String propertyName) {
         final String fullName     = name.isEmpty() ? propertyName : name + "." + propertyName;
         final Context context = Context.getContextTrusted();
         Class<?> javaClass = null;
         try {
             javaClass = context.findClass(fullName);
         } catch (final NoClassDefFoundError | ClassNotFoundException e) {
             //ignored
         }
         // Check for explicit constructor signature use
         // Example: new (java.awt["Color(int, int,int)"])(2, 3, 4);
         final int openBrace = propertyName.indexOf('(');
         final int closeBrace = propertyName.lastIndexOf(')');
         if (openBrace != -1 || closeBrace != -1) {
             final int lastChar = propertyName.length() - 1;
             if (openBrace == -1 || closeBrace != lastChar) {
                 throw typeError("improper.constructor.signature", propertyName);
             }
             // get the class name and try to load it
             final String className = name + "." + propertyName.substring(0, openBrace);
             try {
                 javaClass = context.findClass(className);
             } catch (final NoClassDefFoundError | ClassNotFoundException e) {
                 throw typeError(e, "no.such.java.class", className);
             }
             // try to find a matching constructor
             final Object constructor = BeansLinker.getConstructorMethod(
                     javaClass, propertyName.substring(openBrace + 1, lastChar));
             if (constructor != null) {
                 set(propertyName, constructor, 0);
                 return constructor;
             }
             // we didn't find a matching constructor!
             throw typeError("no.such.java.constructor", propertyName);
         }
         final Object propertyValue;
         if (javaClass == null) {
             propertyValue = new NativeJavaPackage(fullName, getProto());
         } else {
             propertyValue = StaticClass.forClass(javaClass);
         }
         set(propertyName, propertyValue, 0);
         return propertyValue;
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/internal/runtime/NativeJavaPackage.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/NativeJavaPackage.java