Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 java.base.jmod - Base Module
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module.
JDK 17 Base module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.base.jmod.
JDK 17 Base module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Base module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/lang/constant/DirectMethodHandleDesc.java
/* * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.constant; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandleInfo; import java.util.OptionalInt; import java.util.stream.Stream; import jdk.internal.vm.annotation.Stable; import static java.lang.invoke.MethodHandleInfo.REF_getField; import static java.lang.invoke.MethodHandleInfo.REF_getStatic; import static java.lang.invoke.MethodHandleInfo.REF_invokeInterface; import static java.lang.invoke.MethodHandleInfo.REF_invokeSpecial; import static java.lang.invoke.MethodHandleInfo.REF_invokeStatic; import static java.lang.invoke.MethodHandleInfo.REF_invokeVirtual; import static java.lang.invoke.MethodHandleInfo.REF_newInvokeSpecial; import static java.lang.invoke.MethodHandleInfo.REF_putField; import static java.lang.invoke.MethodHandleInfo.REF_putStatic; /** * A <a href="package-summary.html#nominal">nominal descriptor</a> for a direct * {@link MethodHandle}. A {@linkplain DirectMethodHandleDesc} corresponds to * a {@code Constant_MethodHandle_info} entry in the constant pool of a classfile. * * @since 12 */ public sealed interface DirectMethodHandleDesc extends MethodHandleDesc permits DirectMethodHandleDescImpl { /** * Kinds of method handles that can be described with {@linkplain DirectMethodHandleDesc}. * * @since 12 */ enum Kind { /** A method handle for a method invoked as with {@code invokestatic} */ STATIC(REF_invokeStatic), /** A method handle for a method invoked as with {@code invokestatic} */ INTERFACE_STATIC(REF_invokeStatic, true), /** A method handle for a method invoked as with {@code invokevirtual} */ VIRTUAL(REF_invokeVirtual), /** A method handle for a method invoked as with {@code invokeinterface} */ INTERFACE_VIRTUAL(REF_invokeInterface, true), /** A method handle for a method invoked as with {@code invokespecial} */ SPECIAL(REF_invokeSpecial), /** A method handle for an interface method invoked as with {@code invokespecial} */ INTERFACE_SPECIAL(REF_invokeSpecial, true), /** A method handle for a constructor */ CONSTRUCTOR(REF_newInvokeSpecial), /** A method handle for a read accessor for an instance field */ GETTER(REF_getField), /** A method handle for a write accessor for an instance field */ SETTER(REF_putField), /** A method handle for a read accessor for a static field */ STATIC_GETTER(REF_getStatic), /** A method handle for a write accessor for a static field */ STATIC_SETTER(REF_putStatic); /** The corresponding {@code refKind} value for this kind of method handle, * as defined by {@link MethodHandleInfo} */ public final int refKind; /** Is this an interface */ public final boolean isInterface; Kind(int refKind) { this(refKind, false); } Kind(int refKind, boolean isInterface) { this.refKind = refKind; this.isInterface = isInterface; } /** * Returns the enumeration member with the given {@code refKind} field. * Behaves as if {@code valueOf(refKind, false)}. As a special case, * if {@code refKind} is {@code REF_invokeInterface} (9) then the * {@code isInterface} field will be true. * * @param refKind refKind of desired member * @return the matching enumeration member * @throws IllegalArgumentException if there is no such member */ public static Kind valueOf(int refKind) { return valueOf(refKind, refKind == REF_invokeInterface); } /** * Returns the enumeration member with the given the {@code refKind} and * {@code isInterface} arguments. * For most values of {@code refKind} there is an exact match regardless of the value of {@code isInterface}. * These are: * <UL> * <LI>{@code REF_invokeVirtual} which matches to {@code VIRTUAL} * <LI>{@code REF_invokeInterface} which matches to {@code INTERFACE_VIRTUAL} * <LI>{@code REF_newInvokeSpecial} which matches to {@code CONSTRUCTOR} * <LI>{@code REF_getField} which matches to {@code GETTER} * <LI>{@code REF_putField} which matches to {@code SETTER} * <LI>{@code REF_getStatic} which matches to {@code STATIC_GETTER} * <LI>{@code REF_putStatic} which matches to {@code STATIC_SETTER} * </UL> * As for the rest, the returned kind will depend on the value (false or true accordingly) of {@code isInterface}: * <UL> * <LI>{@code REF_invokeStatic} which matches to {@code STATIC} or {@code INTERFACE_STATIC} * <LI>{@code REF_invokeSpecial} which matches to {@code SPECIAL} or {@code INTERFACE_SPECIAL} * </UL> * @param refKind refKind of desired member * @param isInterface whether desired member is for interface methods * @return the matching enumeration member * @throws IllegalArgumentException if there is no such member */ public static Kind valueOf(int refKind, boolean isInterface) { int i = tableIndex(refKind, isInterface); if (i >= 2 && i < TABLE.length) { return TABLE[i]; } throw new IllegalArgumentException(String.format("refKind=%d isInterface=%s", refKind, isInterface)); } private static int tableIndex(int refKind, boolean isInterface) { if (refKind < 0) return refKind; return (refKind * 2) + (isInterface ? 1 : 0); } private static final @Stable Kind[] TABLE; static { // Pack the static table. int max = 0; for (Kind k : values()) max = Math.max(max, tableIndex(k.refKind, true)); TABLE = new Kind[max+1]; for (Kind kind : values()) { int i = tableIndex(kind.refKind, kind.isInterface); if (i >= TABLE.length || TABLE[i] != null) throw new AssertionError("TABLE entry for " + kind); TABLE[i] = kind; } // Pack in some aliases also. int ii = tableIndex(REF_invokeInterface, false); if (TABLE[ii] != null) throw new AssertionError("TABLE entry for (invokeInterface, false) used by " + TABLE[ii]); TABLE[ii] = INTERFACE_VIRTUAL; for (Kind kind : values()) { if (!kind.isInterface) { // Add extra cache entry to alias the isInterface case. // For example, (REF_getStatic, X) will produce STATIC_GETTER // for either truth value of X. int i = tableIndex(kind.refKind, true); if (TABLE[i] == null) { TABLE[i] = kind; } } } } /** * Does this {@code Kind} correspond to a virtual method invocation? * * @return if this {@code Kind} corresponds to a virtual method invocation */ boolean isVirtualMethod() { switch (this) { case VIRTUAL: case SPECIAL: case INTERFACE_VIRTUAL: case INTERFACE_SPECIAL: return true; default: return false; } } } /** * Returns the {@code kind} of the method handle described by this nominal * descriptor. * * @return the {@link Kind} */ Kind kind(); /** * Returns the {@code refKind} of the method handle described by this nominal * reference, as defined by {@link MethodHandleInfo}. * * @return the reference kind */ int refKind(); /** * Indicates if the method is declared by an interface * * @return true if the method is declared by an interface */ boolean isOwnerInterface(); /** * Returns a {@link ClassDesc} describing the class declaring the * method or field described by this nominal descriptor. * * @return the class declaring the method or field */ ClassDesc owner(); /** * Returns the name of the method or field described by this nominal descriptor. * For constructors, returns the reserved name {@code "<init>"}. * * @return the name of the method or field */ String methodName(); /** * Returns the lookup descriptor of the method handle described by this descriptor, * after adjusting for the invocation mode. This will correspond to either * a method type descriptor string (for methods and constructors), or a field * descriptor string (for field access method handles). The lookup descriptor * string is in the same format as accepted by {@link MethodHandleDesc#of(Kind, ClassDesc, String, String)}. * * @return the lookup descriptor string */ String lookupDescriptor(); }
⏎ java/lang/constant/DirectMethodHandleDesc.java
Or download all of them as a single archive file:
File name: java.base-17.0.5-src.zip File size: 8883851 bytes Release date: 2022-09-13 Download
2023-09-26, 93448👍, 1💬
Popular Posts:
maven-settings-builder-3 .8.6.jaris the JAR file for Apache Maven 3.8.6 Settings Builder module. Apa...
JDK 11 jdk.internal.opt.jmod is the JMOD file for JDK 11 Internal Opt module. JDK 11 Internal Opt mo...
What is jxl.jar 2.6.12? jxl.jar 2.6.12 is the JAR file for Java Excel API 2.6.12, which is a Java li...
JDK 11 java.xml.crypto.jmod is the JMOD file for JDK 11 XML (eXtensible Markup Language) Crypto modu...
ZooKeeper is a centralized service for maintaining configuration information, naming, providing dist...