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 

 

JDK 17 java.compiler.jmod - Compiler Module

JDK 17 Modules List

JDK 17 JMod/Module Files

⇑⇑ FAQ for JDK (Java Development Kit) 17

2023-09-26, 39120👍, 1💬