JDK 11 jdk.scripting.nashorn.jmod is the JMOD file for JDK 11 Scripting Nashorn module.

JDK 11 Scripting Nashorn module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.scripting.nashorn.jmod.

JDK 11 Scripting Nashorn module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.

JDK 11 Scripting Nashorn module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.scripting.nashorn.

You can click and view the content of each source code file in the list below.

⏎ jdk/nashorn/internal/runtime/PropertySwitchPoints.java

/*
 * Copyright (c) 2010, 2017, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package jdk.nashorn.internal.runtime;

import java.lang.invoke.SwitchPoint;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.atomic.LongAdder;

/**
 * Helper class for tracking and invalidation of switchpoints for inherited properties.
 */
public class PropertySwitchPoints {

    private final Map<Object, WeakSwitchPointSet> switchPointMap = new HashMap<>();

    private final static SwitchPoint[] EMPTY_SWITCHPOINT_ARRAY = new SwitchPoint[0];

    // These counters are updated in debug mode
    private static LongAdder switchPointsAdded;
    private static LongAdder switchPointsInvalidated;

    static {
        if (Context.DEBUG) {
            switchPointsAdded = new LongAdder();
            switchPointsInvalidated = new LongAdder();
        }
    }

    /**
     * Copy constructor
     *
     * @param switchPoints Proto switchpoints to copy
     */
    private PropertySwitchPoints(final PropertySwitchPoints switchPoints) {
        if (switchPoints != null) {
            // We need to copy the nested weak sets in order to avoid concurrent modification issues, see JDK-8146274
            synchronized (switchPoints) {
                for (final Map.Entry<Object, WeakSwitchPointSet> entry : switchPoints.switchPointMap.entrySet()) {
                    this.switchPointMap.put(entry.getKey(), new WeakSwitchPointSet(entry.getValue()));
                }
            }
        }
    }

    /**
     * Return aggregate switchpoints added to all ProtoSwitchPoints
     * @return the number of switchpoints added
     */
    public static long getSwitchPointsAdded() {
        return switchPointsAdded.longValue();
    }

    /**
     * Return aggregate switchPointMap invalidated in all ProtoSwitchPoints
     * @return the number of switchpoints invalidated
     */
    public static long getSwitchPointsInvalidated() {
        return switchPointsInvalidated.longValue();
    }

    /**
     * Return number of property switchPoints added to a ScriptObject.
     * @param obj the object
     * @return the switchpoint count
     */
    public static int getSwitchPointCount(final ScriptObject obj) {
        return obj.getMap().getSwitchPointCount();
    }

    /**
     * Return the number of switchpoints added to this ProtoSwitchPoints instance.
     * @return the switchpoint count;
     */
    int getSwitchPointCount() {
        return switchPointMap.size();
    }

    /**
     * Add {@code switchPoint} to the switchpoints for for property {@code key}, creating
     * and returning a new {@code ProtoSwitchPoints} instance if the switchpoint was not already contained
     *
     * @param oldSwitchPoints the original PropertySwitchPoints instance. May be null
     * @param key the property key
     * @param switchPoint the switchpoint to be added
     * @return the new PropertySwitchPoints instance, or this instance if switchpoint was already contained
     */
    static PropertySwitchPoints addSwitchPoint(final PropertySwitchPoints oldSwitchPoints, final String key, final SwitchPoint switchPoint) {
        if (oldSwitchPoints == null || !oldSwitchPoints.contains(key, switchPoint)) {
            final PropertySwitchPoints newSwitchPoints = new PropertySwitchPoints(oldSwitchPoints);
            newSwitchPoints.add(key, switchPoint);
            return newSwitchPoints;
        }
        return oldSwitchPoints;
    }

    /**
     * Checks whether {@code switchPoint} is contained in {@code key}'s set.
     *
     * @param key the property key
     * @param switchPoint the switchPoint
     * @return true if switchpoint is already contained for key
     */
    private synchronized boolean contains(final String key, final SwitchPoint switchPoint) {
        final WeakSwitchPointSet set = this.switchPointMap.get(key);
        return set != null && set.contains(switchPoint);
    }

    private synchronized void add(final String key, final SwitchPoint switchPoint) {
        if (Context.DEBUG) {
            switchPointsAdded.increment();
        }

        WeakSwitchPointSet set = this.switchPointMap.get(key);
        if (set == null) {
            set = new WeakSwitchPointSet();
            this.switchPointMap.put(key, set);
        }

        set.add(switchPoint);
    }

    Set<SwitchPoint> getSwitchPoints(final Object key) {
        WeakSwitchPointSet switchPointSet = switchPointMap.get(key);
        if (switchPointSet != null) {
            return switchPointSet.elements();
        }

        return Collections.emptySet();
    }

    /**
     * Invalidate all switchpoints for the given property. This is called when that
     * property is created, deleted, or modified in a script object.
     *
     * @param prop The property to invalidate.
     */
    synchronized void invalidateProperty(final Property prop) {
        final WeakSwitchPointSet set = switchPointMap.get(prop.getKey());
        if (set != null) {
            if (Context.DEBUG) {
                switchPointsInvalidated.add(set.size());
            }
            final SwitchPoint[] switchPoints = set.elements().toArray(EMPTY_SWITCHPOINT_ARRAY);
            SwitchPoint.invalidateAll(switchPoints);
            this.switchPointMap.remove(prop.getKey());
        }
    }


    /**
     * Invalidate all switchpoints except those defined in {@code map}. This is called
     * when the prototype of a script object is changed.
     *
     * @param map map of properties to exclude from invalidation
     */
    synchronized void invalidateInheritedProperties(final PropertyMap map) {
        for (final Map.Entry<Object, WeakSwitchPointSet> entry : switchPointMap.entrySet()) {
            if (map.findProperty(entry.getKey()) != null) {
                continue;
            }
            if (Context.DEBUG) {
                switchPointsInvalidated.add(entry.getValue().size());
            }
            final SwitchPoint[] switchPoints = entry.getValue().elements().toArray(EMPTY_SWITCHPOINT_ARRAY);
            SwitchPoint.invalidateAll(switchPoints);
        }
        switchPointMap.clear();
    }

    private static class WeakSwitchPointSet {

        private final WeakHashMap<SwitchPoint, Void> map;

        WeakSwitchPointSet() {
            map = new WeakHashMap<>();
        }

        WeakSwitchPointSet(final WeakSwitchPointSet set) {
            map = new WeakHashMap<>(set.map);
        }

        void add(final SwitchPoint switchPoint) {
            map.put(switchPoint, null);
        }

        boolean contains(final SwitchPoint switchPoint) {
            return map.containsKey(switchPoint);
        }

        Set<SwitchPoint> elements() {
            return map.keySet();
        }

        int size() {
            return map.size();
        }

    }
}

⏎ jdk/nashorn/internal/runtime/PropertySwitchPoints.java

Or download all of them as a single archive file:

File name: jdk.scripting.nashorn-11.0.1-src.zip
File size: 1390965 bytes
Release date: 2018-11-04
Download 

⇒ JDK 11 jdk.scripting.nashorn.shell.jmod - Scripting Nashorn Shell Module

⇐ JDK 11 jdk.rmic.jmod - RMI Compiler Tool

⇑ Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)