1 /*

     2  * Copyright (c) 2011, 2012, 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 java.security.AccessController;

    29 import java.security.PrivilegedAction;

    30 import sun.misc.Unsafe;

    31 

    32 /**

    33  * This class consists exclusively of static names internal to the

    34  * method handle implementation.

    35  * Usage:  {@code import static java.lang.invoke.MethodHandleStatics.*}

    36  * @author John Rose, JSR 292 EG

    37  */

    38 /*non-public*/ class MethodHandleStatics {

    39 

    40     private MethodHandleStatics() { }  // do not instantiate

    41 

    42     static final Unsafe UNSAFE = Unsafe.getUnsafe();

    43 

    44     static final boolean DEBUG_METHOD_HANDLE_NAMES;

    45     static final boolean DUMP_CLASS_FILES;

    46     static final boolean TRACE_INTERPRETER;

    47     static final boolean TRACE_METHOD_LINKAGE;

    48     static final Integer COMPILE_THRESHOLD;

    49     static {

    50         final Object[] values = { false, false, false, false, null };

    51         AccessController.doPrivileged(new PrivilegedAction<Void>() {

    52                 public Void run() {

    53                     values[0] = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES");

    54                     values[1] = Boolean.getBoolean("java.lang.invoke.MethodHandle.DUMP_CLASS_FILES");

    55                     values[2] = Boolean.getBoolean("java.lang.invoke.MethodHandle.TRACE_INTERPRETER");

    56                     values[3] = Boolean.getBoolean("java.lang.invoke.MethodHandle.TRACE_METHOD_LINKAGE");

    57                     values[4] = Integer.getInteger("java.lang.invoke.MethodHandle.COMPILE_THRESHOLD");

    58                     return null;

    59                 }

    60             });

    61         DEBUG_METHOD_HANDLE_NAMES = (Boolean) values[0];

    62         DUMP_CLASS_FILES          = (Boolean) values[1];

    63         TRACE_INTERPRETER         = (Boolean) values[2];

    64         TRACE_METHOD_LINKAGE      = (Boolean) values[3];

    65         COMPILE_THRESHOLD         = (Integer) values[4];

    66     }

    67 

    68     /** Tell if any of the debugging switches are turned on.

    69      *  If this is the case, it is reasonable to perform extra checks or save extra information.

    70      */

    71     /*non-public*/ static boolean debugEnabled() {

    72         return (DEBUG_METHOD_HANDLE_NAMES |

    73                 DUMP_CLASS_FILES |

    74                 TRACE_INTERPRETER |

    75                 TRACE_METHOD_LINKAGE);

    76     }

    77 

    78     /*non-public*/ static String getNameString(MethodHandle target, MethodType type) {

    79         if (type == null)

    80             type = target.type();

    81         MemberName name = null;

    82         if (target != null)

    83             name = target.internalMemberName();

    84         if (name == null)

    85             return "invoke" + type;

    86         return name.getName() + type;

    87     }

    88 

    89     /*non-public*/ static String getNameString(MethodHandle target, MethodHandle typeHolder) {

    90         return getNameString(target, typeHolder == null ? (MethodType) null : typeHolder.type());

    91     }

    92 

    93     /*non-public*/ static String getNameString(MethodHandle target) {

    94         return getNameString(target, (MethodType) null);

    95     }

    96 

    97     /*non-public*/ static String addTypeString(Object obj, MethodHandle target) {

    98         String str = String.valueOf(obj);

    99         if (target == null)  return str;

   100         int paren = str.indexOf('(');

   101         if (paren >= 0) str = str.substring(0, paren);

   102         return str + target.type();

   103     }

   104 

   105     // handy shared exception makers (they simplify the common case code)

   106     /*non-public*/ static InternalError newInternalError(String message) {

   107         return new InternalError(message);

   108     }

   109     /*non-public*/ static InternalError newInternalError(String message, Throwable cause) {

   110         return new InternalError(message, cause);

   111     }

   112     /*non-public*/ static InternalError newInternalError(Throwable cause) {

   113         return new InternalError(cause);

   114     }

   115     /*non-public*/ static RuntimeException newIllegalStateException(String message) {

   116         return new IllegalStateException(message);

   117     }

   118     /*non-public*/ static RuntimeException newIllegalStateException(String message, Object obj) {

   119         return new IllegalStateException(message(message, obj));

   120     }

   121     /*non-public*/ static RuntimeException newIllegalArgumentException(String message) {

   122         return new IllegalArgumentException(message);

   123     }

   124     /*non-public*/ static RuntimeException newIllegalArgumentException(String message, Object obj) {

   125         return new IllegalArgumentException(message(message, obj));

   126     }

   127     /*non-public*/ static RuntimeException newIllegalArgumentException(String message, Object obj, Object obj2) {

   128         return new IllegalArgumentException(message(message, obj, obj2));

   129     }

   130     /*non-public*/ static Error uncaughtException(Throwable ex) {

   131         throw newInternalError("uncaught exception", ex);

   132     }

   133     static Error NYI() {

   134         throw new AssertionError("NYI");

   135     }

   136     private static String message(String message, Object obj) {

   137         if (obj != null)  message = message + ": " + obj;

   138         return message;

   139     }

   140     private static String message(String message, Object obj, Object obj2) {

   141         if (obj != null || obj2 != null)  message = message + ": " + obj + ", " + obj2;

   142         return message;

   143     }

   144 }