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 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/internal/module/ModuleBootstrap.java
/* * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package jdk.internal.module; import java.io.File; import java.io.PrintStream; import java.lang.module.Configuration; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleFinder; import java.lang.module.ModuleReference; import java.lang.module.ResolvedModule; import java.net.URI; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; import jdk.internal.loader.BootLoader; import jdk.internal.loader.BuiltinClassLoader; import jdk.internal.misc.JavaLangAccess; import jdk.internal.misc.JavaLangModuleAccess; import jdk.internal.misc.SharedSecrets; import jdk.internal.perf.PerfCounter; /** * Initializes/boots the module system. * * The {@link #boot() boot} method is called early in the startup to initialize * the module system. In summary, the boot method creates a Configuration by * resolving a set of module names specified via the launcher (or equivalent) * -m and --add-modules options. The modules are located on a module path that * is constructed from the upgrade module path, system modules, and application * module path. The Configuration is instantiated as the boot layer with each * module in the configuration defined to a class loader. */ public final class ModuleBootstrap { private ModuleBootstrap() { } private static final String JAVA_BASE = "java.base"; // the token for "all default modules" private static final String ALL_DEFAULT = "ALL-DEFAULT"; // the token for "all unnamed modules" private static final String ALL_UNNAMED = "ALL-UNNAMED"; // the token for "all system modules" private static final String ALL_SYSTEM = "ALL-SYSTEM"; // the token for "all modules on the module path" private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH"; // access to java.lang/module private static final JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess(); // The ModulePatcher for the initial configuration private static final ModulePatcher patcher = initModulePatcher(); /** * Returns the ModulePatcher for the initial configuration. */ public static ModulePatcher patcher() { return patcher; } // ModuleFinders for the initial configuration private static volatile ModuleFinder unlimitedFinder; private static volatile ModuleFinder limitedFinder; /** * Returns the ModuleFinder for the initial configuration before * observability is limited by the --limit-modules command line option. * * @apiNote Used to support locating modules {@code java.instrument} and * {@code jdk.management.agent} modules when they are loaded dynamically. */ public static ModuleFinder unlimitedFinder() { ModuleFinder finder = unlimitedFinder; if (finder == null) { return ModuleFinder.ofSystem(); } else { return finder; } } /** * Returns the ModuleFinder for the initial configuration. * * @apiNote Used to support "{@code java --list-modules}". */ public static ModuleFinder limitedFinder() { ModuleFinder finder = limitedFinder; if (finder == null) { return unlimitedFinder(); } else { return finder; } } /** * Initialize the module system, returning the boot layer. * * @see java.lang.System#initPhase2(boolean, boolean) */ public static ModuleLayer boot() throws Exception { // Step 0: Command line options long t0 = System.nanoTime(); ModuleFinder upgradeModulePath = finderFor("jdk.module.upgrade.path"); ModuleFinder appModulePath = finderFor("jdk.module.path"); boolean isPatched = patcher.hasPatches(); String mainModule = System.getProperty("jdk.module.main"); Set<String> addModules = addModules(); Set<String> limitModules = limitModules(); PrintStream traceOutput = null; String trace = getAndRemoveProperty("jdk.module.showModuleResolution"); if (trace != null && Boolean.parseBoolean(trace)) traceOutput = System.out; // Step 1: The observable system modules, either all system modules // or the system modules pre-generated for the initial module (the // initial module may be the unnamed module). If the system modules // are pre-generated for the initial module then resolution can be // skipped. long t1 = System.nanoTime(); SystemModules systemModules = null; ModuleFinder systemModuleFinder; boolean haveModulePath = (appModulePath != null || upgradeModulePath != null); boolean needResolution = true; if (!haveModulePath && addModules.isEmpty() && limitModules.isEmpty()) { systemModules = SystemModuleFinders.systemModules(mainModule); if (systemModules != null && !isPatched && (traceOutput == null)) { needResolution = false; } } if (systemModules == null) { // all system modules are observable systemModules = SystemModuleFinders.allSystemModules(); } if (systemModules != null) { // images build systemModuleFinder = SystemModuleFinders.of(systemModules); } else { // exploded build or testing systemModules = new ExplodedSystemModules(); systemModuleFinder = SystemModuleFinders.ofSystem(); } Counters.add("jdk.module.boot.1.systemModulesTime", t1); // Step 2: Define and load java.base. This patches all classes loaded // to date so that they are members of java.base. Once java.base is // loaded then resources in java.base are available for error messages // needed from here on. long t2 = System.nanoTime(); ModuleReference base = systemModuleFinder.find(JAVA_BASE).orElse(null); if (base == null) throw new InternalError(JAVA_BASE + " not found"); URI baseUri = base.location().orElse(null); if (baseUri == null) throw new InternalError(JAVA_BASE + " does not have a location"); BootLoader.loadModule(base); Modules.defineModule(null, base.descriptor(), baseUri); Counters.add("jdk.module.boot.2.defineBaseTime", t2); // Step 2a: Scan all modules when --validate-modules specified if (getAndRemoveProperty("jdk.module.validation") != null) { int errors = ModulePathValidator.scanAllModules(System.out); if (errors > 0) { fail("Validation of module path failed"); } } // Step 3: If resolution is needed then create the module finder and // the set of root modules to resolve. long t3 = System.nanoTime(); ModuleFinder savedModuleFinder = null; ModuleFinder finder; Set<String> roots; if (needResolution) { // upgraded modules override the modules in the run-time image if (upgradeModulePath != null) systemModuleFinder = ModuleFinder.compose(upgradeModulePath, systemModuleFinder); // The module finder: [--upgrade-module-path] system [--module-path] if (appModulePath != null) { finder = ModuleFinder.compose(systemModuleFinder, appModulePath); } else { finder = systemModuleFinder; } // The root modules to resolve roots = new HashSet<>(); // launcher -m option to specify the main/initial module if (mainModule != null) roots.add(mainModule); // additional module(s) specified by --add-modules boolean addAllDefaultModules = false; boolean addAllSystemModules = false; boolean addAllApplicationModules = false; for (String mod : addModules) { switch (mod) { case ALL_DEFAULT: addAllDefaultModules = true; break; case ALL_SYSTEM: addAllSystemModules = true; break; case ALL_MODULE_PATH: addAllApplicationModules = true; break; default: roots.add(mod); } } // --limit-modules savedModuleFinder = finder; if (!limitModules.isEmpty()) { finder = limitFinder(finder, limitModules, roots); } // If there is no initial module specified then assume that the initial // module is the unnamed module of the application class loader. This // is implemented by resolving all observable modules that export an // API. Modules that have the DO_NOT_RESOLVE_BY_DEFAULT bit set in // their ModuleResolution attribute flags are excluded from the // default set of roots. if (mainModule == null || addAllDefaultModules) { roots.addAll(DefaultRoots.compute(systemModuleFinder, finder)); } // If `--add-modules ALL-SYSTEM` is specified then all observable system // modules will be resolved. if (addAllSystemModules) { ModuleFinder f = finder; // observable modules systemModuleFinder.findAll() .stream() .map(ModuleReference::descriptor) .map(ModuleDescriptor::name) .filter(mn -> f.find(mn).isPresent()) // observable .forEach(mn -> roots.add(mn)); } // If `--add-modules ALL-MODULE-PATH` is specified then all observable // modules on the application module path will be resolved. if (appModulePath != null && addAllApplicationModules) { ModuleFinder f = finder; // observable modules appModulePath.findAll() .stream() .map(ModuleReference::descriptor) .map(ModuleDescriptor::name) .filter(mn -> f.find(mn).isPresent()) // observable .forEach(mn -> roots.add(mn)); } } else { // no resolution case finder = systemModuleFinder; roots = null; } Counters.add("jdk.module.boot.3.optionsAndRootsTime", t3); // Step 4: Resolve the root modules, with service binding, to create // the configuration for the boot layer. If resolution is not needed // then create the configuration for the boot layer from the // readability graph created at link time. long t4 = System.nanoTime(); Configuration cf; if (needResolution) { cf = JLMA.resolveAndBind(finder, roots, traceOutput); } else { Map<String, Set<String>> map = systemModules.moduleReads(); cf = JLMA.newConfiguration(systemModuleFinder, map); } // check that modules specified to --patch-module are resolved if (isPatched) { patcher.patchedModules() .stream() .filter(mn -> !cf.findModule(mn).isPresent()) .forEach(mn -> warnUnknownModule(PATCH_MODULE, mn)); } Counters.add("jdk.module.boot.4.resolveTime", t4); // Step 5: Map the modules in the configuration to class loaders. // The static configuration provides the mapping of standard and JDK // modules to the boot and platform loaders. All other modules (JDK // tool modules, and both explicit and automatic modules on the // application module path) are defined to the application class // loader. long t5 = System.nanoTime(); // mapping of modules to class loaders Function<String, ClassLoader> clf = ModuleLoaderMap.mappingFunction(cf); // check that all modules to be mapped to the boot loader will be // loaded from the runtime image if (haveModulePath) { for (ResolvedModule resolvedModule : cf.modules()) { ModuleReference mref = resolvedModule.reference(); String name = mref.descriptor().name(); ClassLoader cl = clf.apply(name); if (cl == null) { if (upgradeModulePath != null && upgradeModulePath.find(name).isPresent()) fail(name + ": cannot be loaded from upgrade module path"); if (!systemModuleFinder.find(name).isPresent()) fail(name + ": cannot be loaded from application module path"); } } } // check for split packages in the modules mapped to the built-in loaders if (systemModules.hasSplitPackages() || isPatched || haveModulePath) { checkSplitPackages(cf, clf); } // load/register the modules with the built-in class loaders loadModules(cf, clf); Counters.add("jdk.module.boot.5.loadModulesTime", t5); // Step 6: Define all modules to the VM long t6 = System.nanoTime(); ModuleLayer bootLayer = ModuleLayer.empty().defineModules(cf, clf); Counters.add("jdk.module.boot.6.layerCreateTime", t6); // Step 7: Miscellaneous // check incubating status if (systemModules.hasIncubatorModules() || haveModulePath) { checkIncubatingStatus(cf); } // --add-reads, --add-exports/--add-opens, and --illegal-access long t7 = System.nanoTime(); addExtraReads(bootLayer); boolean extraExportsOrOpens = addExtraExportsAndOpens(bootLayer); addIllegalAccess(upgradeModulePath, systemModules, bootLayer, extraExportsOrOpens); Counters.add("jdk.module.boot.7.adjustModulesTime", t7); // save module finders for later use if (savedModuleFinder != null) { unlimitedFinder = new SafeModuleFinder(savedModuleFinder); if (savedModuleFinder != finder) limitedFinder = new SafeModuleFinder(finder); } // total time to initialize Counters.add("jdk.module.boot.totalTime", t0); Counters.publish(); return bootLayer; } /** * Load/register the modules to the built-in class loaders. */ private static void loadModules(Configuration cf, Function<String, ClassLoader> clf) { for (ResolvedModule resolvedModule : cf.modules()) { ModuleReference mref = resolvedModule.reference(); String name = resolvedModule.name(); ClassLoader loader = clf.apply(name); if (loader == null) { // skip java.base as it is already loaded if (!name.equals(JAVA_BASE)) { BootLoader.loadModule(mref); } } else if (loader instanceof BuiltinClassLoader) { ((BuiltinClassLoader) loader).loadModule(mref); } } } /** * Checks for split packages between modules defined to the built-in class * loaders. */ private static void checkSplitPackages(Configuration cf, Function<String, ClassLoader> clf) { Map<String, String> packageToModule = new HashMap<>(); for (ResolvedModule resolvedModule : cf.modules()) { ModuleDescriptor descriptor = resolvedModule.reference().descriptor(); String name = descriptor.name(); ClassLoader loader = clf.apply(name); if (loader == null || loader instanceof BuiltinClassLoader) { for (String p : descriptor.packages()) { String other = packageToModule.putIfAbsent(p, name); if (other != null) { String msg = "Package " + p + " in both module " + name + " and module " + other; throw new LayerInstantiationException(msg); } } } } } /** * Returns a ModuleFinder that limits observability to the given root * modules, their transitive dependences, plus a set of other modules. */ private static ModuleFinder limitFinder(ModuleFinder finder, Set<String> roots, Set<String> otherMods) { // resolve all root modules Configuration cf = Configuration.empty().resolve(finder, ModuleFinder.of(), roots); // module name -> reference Map<String, ModuleReference> map = new HashMap<>(); // root modules and their transitive dependences cf.modules().stream() .map(ResolvedModule::reference) .forEach(mref -> map.put(mref.descriptor().name(), mref)); // additional modules otherMods.stream() .map(finder::find) .flatMap(Optional::stream) .forEach(mref -> map.putIfAbsent(mref.descriptor().name(), mref)); // set of modules that are observable Set<ModuleReference> mrefs = new HashSet<>(map.values()); return new ModuleFinder() { @Override public Optional<ModuleReference> find(String name) { return Optional.ofNullable(map.get(name)); } @Override public Set<ModuleReference> findAll() { return mrefs; } }; } /** * Creates a finder from the module path that is the value of the given * system property and optionally patched by --patch-module */ private static ModuleFinder finderFor(String prop) { String s = System.getProperty(prop); if (s == null) { return null; } else { String[] dirs = s.split(File.pathSeparator); Path[] paths = new Path[dirs.length]; int i = 0; for (String dir: dirs) { paths[i++] = Path.of(dir); } return ModulePath.of(patcher, paths); } } /** * Initialize the module patcher for the initial configuration passed on the * value of the --patch-module options. */ private static ModulePatcher initModulePatcher() { Map<String, List<String>> map = decode("jdk.module.patch.", File.pathSeparator, false); return new ModulePatcher(map); } /** * Returns the set of module names specified by --add-module options. */ private static Set<String> addModules() { String prefix = "jdk.module.addmods."; int index = 0; // the system property is removed after decoding String value = getAndRemoveProperty(prefix + index); if (value == null) { return Collections.emptySet(); } else { Set<String> modules = new HashSet<>(); while (value != null) { for (String s : value.split(",")) { if (s.length() > 0) modules.add(s); } index++; value = getAndRemoveProperty(prefix + index); } return modules; } } /** * Returns the set of module names specified by --limit-modules. */ private static Set<String> limitModules() { String value = getAndRemoveProperty("jdk.module.limitmods"); if (value == null) { return Collections.emptySet(); } else { Set<String> names = new HashSet<>(); for (String name : value.split(",")) { if (name.length() > 0) names.add(name); } return names; } } /** * Process the --add-reads options to add any additional read edges that * are specified on the command-line. */ private static void addExtraReads(ModuleLayer bootLayer) { // decode the command line options Map<String, List<String>> map = decode("jdk.module.addreads."); if (map.isEmpty()) return; for (Map.Entry<String, List<String>> e : map.entrySet()) { // the key is $MODULE String mn = e.getKey(); Optional<Module> om = bootLayer.findModule(mn); if (!om.isPresent()) { warnUnknownModule(ADD_READS, mn); continue; } Module m = om.get(); // the value is the set of other modules (by name) for (String name : e.getValue()) { if (ALL_UNNAMED.equals(name)) { Modules.addReadsAllUnnamed(m); } else { om = bootLayer.findModule(name); if (om.isPresent()) { Modules.addReads(m, om.get()); } else { warnUnknownModule(ADD_READS, name); } } } } } /** * Process the --add-exports and --add-opens options to export/open * additional packages specified on the command-line. */ private static boolean addExtraExportsAndOpens(ModuleLayer bootLayer) { boolean extraExportsOrOpens = false; // --add-exports String prefix = "jdk.module.addexports."; Map<String, List<String>> extraExports = decode(prefix); if (!extraExports.isEmpty()) { addExtraExportsOrOpens(bootLayer, extraExports, false); extraExportsOrOpens = true; } // --add-opens prefix = "jdk.module.addopens."; Map<String, List<String>> extraOpens = decode(prefix); if (!extraOpens.isEmpty()) { addExtraExportsOrOpens(bootLayer, extraOpens, true); extraExportsOrOpens = true; } return extraExportsOrOpens; } private static void addExtraExportsOrOpens(ModuleLayer bootLayer, Map<String, List<String>> map, boolean opens) { String option = opens ? ADD_OPENS : ADD_EXPORTS; for (Map.Entry<String, List<String>> e : map.entrySet()) { // the key is $MODULE/$PACKAGE String key = e.getKey(); String[] s = key.split("/"); if (s.length != 2) fail(unableToParse(option, "<module>/<package>", key)); String mn = s[0]; String pn = s[1]; if (mn.isEmpty() || pn.isEmpty()) fail(unableToParse(option, "<module>/<package>", key)); // The exporting module is in the boot layer Module m; Optional<Module> om = bootLayer.findModule(mn); if (!om.isPresent()) { warnUnknownModule(option, mn); continue; } m = om.get(); if (!m.getDescriptor().packages().contains(pn)) { warn("package " + pn + " not in " + mn); continue; } // the value is the set of modules to export to (by name) for (String name : e.getValue()) { boolean allUnnamed = false; Module other = null; if (ALL_UNNAMED.equals(name)) { allUnnamed = true; } else { om = bootLayer.findModule(name); if (om.isPresent()) { other = om.get(); } else { warnUnknownModule(option, name); continue; } } if (allUnnamed) { if (opens) { Modules.addOpensToAllUnnamed(m, pn); } else { Modules.addExportsToAllUnnamed(m, pn); } } else { if (opens) { Modules.addOpens(m, pn, other); } else { Modules.addExports(m, pn, other); } } } } } /** * Process the --illegal-access option (and its default) to open packages * of system modules in the boot layer to code in unnamed modules. */ private static void addIllegalAccess(ModuleFinder upgradeModulePath, SystemModules systemModules, ModuleLayer bootLayer, boolean extraExportsOrOpens) { String value = getAndRemoveProperty("jdk.module.illegalAccess"); IllegalAccessLogger.Mode mode = IllegalAccessLogger.Mode.ONESHOT; if (value != null) { switch (value) { case "deny": return; case "permit": break; case "warn": mode = IllegalAccessLogger.Mode.WARN; break; case "debug": mode = IllegalAccessLogger.Mode.DEBUG; break; default: fail("Value specified to --illegal-access not recognized:" + " '" + value + "'"); return; } } IllegalAccessLogger.Builder builder = new IllegalAccessLogger.Builder(mode, System.err); Map<String, Set<String>> map1 = systemModules.concealedPackagesToOpen(); Map<String, Set<String>> map2 = systemModules.exportedPackagesToOpen(); if (map1.isEmpty() && map2.isEmpty()) { // need to generate (exploded build) IllegalAccessMaps maps = IllegalAccessMaps.generate(limitedFinder()); map1 = maps.concealedPackagesToOpen(); map2 = maps.exportedPackagesToOpen(); } // open specific packages in the system modules for (Module m : bootLayer.modules()) { ModuleDescriptor descriptor = m.getDescriptor(); String name = m.getName(); // skip open modules if (descriptor.isOpen()) { continue; } // skip modules loaded from the upgrade module path if (upgradeModulePath != null && upgradeModulePath.find(name).isPresent()) { continue; } Set<String> concealedPackages = map1.getOrDefault(name, Set.of()); Set<String> exportedPackages = map2.getOrDefault(name, Set.of()); // refresh the set of concealed and exported packages if needed if (extraExportsOrOpens) { concealedPackages = new HashSet<>(concealedPackages); exportedPackages = new HashSet<>(exportedPackages); Iterator<String> iterator = concealedPackages.iterator(); while (iterator.hasNext()) { String pn = iterator.next(); if (m.isExported(pn, BootLoader.getUnnamedModule())) { // concealed package is exported to ALL-UNNAMED iterator.remove(); exportedPackages.add(pn); } } iterator = exportedPackages.iterator(); while (iterator.hasNext()) { String pn = iterator.next(); if (m.isOpen(pn, BootLoader.getUnnamedModule())) { // exported package is opened to ALL-UNNAMED iterator.remove(); } } } // log reflective access to all types in concealed packages builder.logAccessToConcealedPackages(m, concealedPackages); // log reflective access to non-public members/types in exported packages builder.logAccessToExportedPackages(m, exportedPackages); // open the packages to unnamed modules JavaLangAccess jla = SharedSecrets.getJavaLangAccess(); jla.addOpensToAllUnnamed(m, concat(concealedPackages.iterator(), exportedPackages.iterator())); } builder.complete(); } /** * Decodes the values of --add-reads, -add-exports, --add-opens or * --patch-modules options that are encoded in system properties. * * @param prefix the system property prefix * @praam regex the regex for splitting the RHS of the option value */ private static Map<String, List<String>> decode(String prefix, String regex, boolean allowDuplicates) { int index = 0; // the system property is removed after decoding String value = getAndRemoveProperty(prefix + index); if (value == null) return Collections.emptyMap(); Map<String, List<String>> map = new HashMap<>(); while (value != null) { int pos = value.indexOf('='); if (pos == -1) fail(unableToParse(option(prefix), "<module>=<value>", value)); if (pos == 0) fail(unableToParse(option(prefix), "<module>=<value>", value)); // key is <module> or <module>/<package> String key = value.substring(0, pos); String rhs = value.substring(pos+1); if (rhs.isEmpty()) fail(unableToParse(option(prefix), "<module>=<value>", value)); // value is <module>(,<module>)* or <file>(<pathsep><file>)* if (!allowDuplicates && map.containsKey(key)) fail(key + " specified more than once to " + option(prefix)); List<String> values = map.computeIfAbsent(key, k -> new ArrayList<>()); int ntargets = 0; for (String s : rhs.split(regex)) { if (s.length() > 0) { values.add(s); ntargets++; } } if (ntargets == 0) fail("Target must be specified: " + option(prefix) + " " + value); index++; value = getAndRemoveProperty(prefix + index); } return map; } /** * Decodes the values of --add-reads, -add-exports or --add-opens * which use the "," to separate the RHS of the option value. */ private static Map<String, List<String>> decode(String prefix) { return decode(prefix, ",", true); } /** * Gets and remove the named system property */ private static String getAndRemoveProperty(String key) { return (String)System.getProperties().remove(key); } /** * Checks incubating status of modules in the configuration */ private static void checkIncubatingStatus(Configuration cf) { String incubating = null; for (ResolvedModule resolvedModule : cf.modules()) { ModuleReference mref = resolvedModule.reference(); // emit warning if the WARN_INCUBATING module resolution bit set if (ModuleResolution.hasIncubatingWarning(mref)) { String mn = mref.descriptor().name(); if (incubating == null) { incubating = mn; } else { incubating += ", " + mn; } } } if (incubating != null) warn("Using incubator modules: " + incubating); } /** * Throws a RuntimeException with the given message */ static void fail(String m) { throw new RuntimeException(m); } static void warn(String m) { System.err.println("WARNING: " + m); } static void warnUnknownModule(String option, String mn) { warn("Unknown module: " + mn + " specified to " + option); } static String unableToParse(String option, String text, String value) { return "Unable to parse " + option + " " + text + ": " + value; } private static final String ADD_MODULES = "--add-modules"; private static final String ADD_EXPORTS = "--add-exports"; private static final String ADD_OPENS = "--add-opens"; private static final String ADD_READS = "--add-reads"; private static final String PATCH_MODULE = "--patch-module"; /* * Returns the command-line option name corresponds to the specified * system property prefix. */ static String option(String prefix) { switch (prefix) { case "jdk.module.addexports.": return ADD_EXPORTS; case "jdk.module.addopens.": return ADD_OPENS; case "jdk.module.addreads.": return ADD_READS; case "jdk.module.patch.": return PATCH_MODULE; case "jdk.module.addmods.": return ADD_MODULES; default: throw new IllegalArgumentException(prefix); } } /** * Returns an iterator that yields all elements of the first iterator * followed by all the elements of the second iterator. */ static <T> Iterator<T> concat(Iterator<T> iterator1, Iterator<T> iterator2) { return new Iterator<T>() { @Override public boolean hasNext() { return iterator1.hasNext() || iterator2.hasNext(); } @Override public T next() { if (iterator1.hasNext()) return iterator1.next(); if (iterator2.hasNext()) return iterator2.next(); throw new NoSuchElementException(); } }; } /** * Wraps a (potentially not thread safe) ModuleFinder created during startup * for use after startup. */ static class SafeModuleFinder implements ModuleFinder { private final Set<ModuleReference> mrefs; private volatile Map<String, ModuleReference> nameToModule; SafeModuleFinder(ModuleFinder finder) { this.mrefs = Collections.unmodifiableSet(finder.findAll()); } @Override public Optional<ModuleReference> find(String name) { Objects.requireNonNull(name); Map<String, ModuleReference> nameToModule = this.nameToModule; if (nameToModule == null) { this.nameToModule = nameToModule = mrefs.stream() .collect(Collectors.toMap(m -> m.descriptor().name(), Function.identity())); } return Optional.ofNullable(nameToModule.get(name)); } @Override public Set<ModuleReference> findAll() { return mrefs; } } /** * Counters for startup performance analysis. */ static class Counters { private static final boolean PUBLISH_COUNTERS; private static final boolean PRINT_COUNTERS; private static Map<String, Long> counters; static { String s = System.getProperty("jdk.module.boot.usePerfData"); if (s == null) { PUBLISH_COUNTERS = false; PRINT_COUNTERS = false; } else { PUBLISH_COUNTERS = true; PRINT_COUNTERS = s.equals("debug"); counters = new LinkedHashMap<>(); // preserve insert order } } /** * Add a counter */ static void add(String name, long start) { if (PUBLISH_COUNTERS || PRINT_COUNTERS) { counters.put(name, (System.nanoTime() - start)); } } /** * Publish the counters to the instrumentation buffer or stdout. */ static void publish() { if (PUBLISH_COUNTERS || PRINT_COUNTERS) { for (Map.Entry<String, Long> e : counters.entrySet()) { String name = e.getKey(); long value = e.getValue(); if (PUBLISH_COUNTERS) PerfCounter.newPerfCounter(name).set(value); if (PRINT_COUNTERS) System.out.println(name + " = " + value); } } } } }
⏎ jdk/internal/module/ModuleBootstrap.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 207124👍, 0💬
Popular Posts:
itextpdf.jar is a component in iText 5 Java library to provide core functionalities. iText Java libr...
Xalan-Java, Version 2.7.1, is an XSLT processor for transforming XML documents into HTML, text, or o...
JDK 11 jdk.charsets.jmod is the JMOD file for JDK 11 Charsets module. JDK 11 Charsets module compile...
The Web Services Description Language for Java Toolkit (WSDL4J), Release 1.6.2, allows the creation,...
JDK 11 java.sql.rowset.jmod is the JMOD file for JDK 11 SQL Rowset module. JDK 11 SQL Rowset module ...