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
⏎ java/lang/ProcessEnvironment.java
/* * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ /* We use APIs that access a so-called Windows "Environment Block", * which looks like an array of jchars like this: * * FOO=BAR\u0000 ... GORP=QUUX\u0000\u0000 * * This data structure has a number of peculiarities we must contend with: * (see: http://windowssdk.msdn.microsoft.com/en-us/library/ms682009.aspx) * - The NUL jchar separators, and a double NUL jchar terminator. * It appears that the Windows implementation requires double NUL * termination even if the environment is empty. We should always * generate environments with double NUL termination, while accepting * empty environments consisting of a single NUL. * - on Windows9x, this is actually an array of 8-bit chars, not jchars, * encoded in the system default encoding. * - The block must be sorted by Unicode value, case-insensitively, * as if folded to upper case. * - There are magic environment variables maintained by Windows * that start with a `=' (!) character. These are used for * Windows drive current directory (e.g. "=C:=C:\WINNT") or the * exit code of the last command (e.g. "=ExitCode=0000001"). * * Since Java and non-9x Windows speak the same character set, and * even the same encoding, we don't have to deal with unreliable * conversion to byte streams. Just add a few NUL terminators. * * System.getenv(String) is case-insensitive, while System.getenv() * returns a map that is case-sensitive, which is consistent with * native Windows APIs. * * The non-private methods in this class are not for general use even * within this package. Instead, they are the system-dependent parts * of the system-independent method of the same name. Don't even * think of using this class unless your method's name appears below. * * @author Martin Buchholz * @since 1.5 */ package java.lang; import java.io.*; import java.util.*; final class ProcessEnvironment extends HashMap<String,String> { private static final long serialVersionUID = -8017839552603542824L; private static String validateName(String name) { // An initial `=' indicates a magic Windows variable name -- OK if (name.indexOf('=', 1) != -1 || name.indexOf('\u0000') != -1) throw new IllegalArgumentException ("Invalid environment variable name: \"" + name + "\""); return name; } private static String validateValue(String value) { if (value.indexOf('\u0000') != -1) throw new IllegalArgumentException ("Invalid environment variable value: \"" + value + "\""); return value; } private static String nonNullString(Object o) { if (o == null) throw new NullPointerException(); return (String) o; } public String put(String key, String value) { return super.put(validateName(key), validateValue(value)); } public String get(Object key) { return super.get(nonNullString(key)); } public boolean containsKey(Object key) { return super.containsKey(nonNullString(key)); } public boolean containsValue(Object value) { return super.containsValue(nonNullString(value)); } public String remove(Object key) { return super.remove(nonNullString(key)); } private static class CheckedEntry implements Map.Entry<String,String> { private final Map.Entry<String,String> e; public CheckedEntry(Map.Entry<String,String> e) {this.e = e;} public String getKey() { return e.getKey();} public String getValue() { return e.getValue();} public String setValue(String value) { return e.setValue(validateValue(value)); } public String toString() { return getKey() + "=" + getValue();} public boolean equals(Object o) {return e.equals(o);} public int hashCode() {return e.hashCode();} } private static class CheckedEntrySet extends AbstractSet<Map.Entry<String,String>> { private final Set<Map.Entry<String,String>> s; public CheckedEntrySet(Set<Map.Entry<String,String>> s) {this.s = s;} public int size() {return s.size();} public boolean isEmpty() {return s.isEmpty();} public void clear() { s.clear();} public Iterator<Map.Entry<String,String>> iterator() { return new Iterator<Map.Entry<String,String>>() { Iterator<Map.Entry<String,String>> i = s.iterator(); public boolean hasNext() { return i.hasNext();} public Map.Entry<String,String> next() { return new CheckedEntry(i.next()); } public void remove() { i.remove();} }; } private static Map.Entry<String,String> checkedEntry(Object o) { @SuppressWarnings("unchecked") Map.Entry<String,String> e = (Map.Entry<String,String>) o; nonNullString(e.getKey()); nonNullString(e.getValue()); return e; } public boolean contains(Object o) {return s.contains(checkedEntry(o));} public boolean remove(Object o) {return s.remove(checkedEntry(o));} } private static class CheckedValues extends AbstractCollection<String> { private final Collection<String> c; public CheckedValues(Collection<String> c) {this.c = c;} public int size() {return c.size();} public boolean isEmpty() {return c.isEmpty();} public void clear() { c.clear();} public Iterator<String> iterator() {return c.iterator();} public boolean contains(Object o) {return c.contains(nonNullString(o));} public boolean remove(Object o) {return c.remove(nonNullString(o));} } private static class CheckedKeySet extends AbstractSet<String> { private final Set<String> s; public CheckedKeySet(Set<String> s) {this.s = s;} public int size() {return s.size();} public boolean isEmpty() {return s.isEmpty();} public void clear() { s.clear();} public Iterator<String> iterator() {return s.iterator();} public boolean contains(Object o) {return s.contains(nonNullString(o));} public boolean remove(Object o) {return s.remove(nonNullString(o));} } public Set<String> keySet() { return new CheckedKeySet(super.keySet()); } public Collection<String> values() { return new CheckedValues(super.values()); } public Set<Map.Entry<String,String>> entrySet() { return new CheckedEntrySet(super.entrySet()); } private static final class NameComparator implements Comparator<String> { public int compare(String s1, String s2) { // We can't use String.compareToIgnoreCase since it // canonicalizes to lower case, while Windows // canonicalizes to upper case! For example, "_" should // sort *after* "Z", not before. int n1 = s1.length(); int n2 = s2.length(); int min = Math.min(n1, n2); for (int i = 0; i < min; i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (c1 != c2) { c1 = Character.toUpperCase(c1); c2 = Character.toUpperCase(c2); if (c1 != c2) // No overflow because of numeric promotion return c1 - c2; } } return n1 - n2; } } private static final class EntryComparator implements Comparator<Map.Entry<String,String>> { public int compare(Map.Entry<String,String> e1, Map.Entry<String,String> e2) { return nameComparator.compare(e1.getKey(), e2.getKey()); } } // Allow `=' as first char in name, e.g. =C:=C:\DIR static final int MIN_NAME_LENGTH = 1; private static final NameComparator nameComparator; private static final EntryComparator entryComparator; private static final ProcessEnvironment theEnvironment; private static final Map<String,String> theUnmodifiableEnvironment; private static final Map<String,String> theCaseInsensitiveEnvironment; static { nameComparator = new NameComparator(); entryComparator = new EntryComparator(); theEnvironment = new ProcessEnvironment(); theUnmodifiableEnvironment = Collections.unmodifiableMap(theEnvironment); String envblock = environmentBlock(); int beg, end, eql; for (beg = 0; ((end = envblock.indexOf('\u0000', beg )) != -1 && // An initial `=' indicates a magic Windows variable name -- OK (eql = envblock.indexOf('=' , beg+1)) != -1); beg = end + 1) { // Ignore corrupted environment strings. if (eql < end) theEnvironment.put(envblock.substring(beg, eql), envblock.substring(eql+1,end)); } theCaseInsensitiveEnvironment = new TreeMap<>(nameComparator); theCaseInsensitiveEnvironment.putAll(theEnvironment); } private ProcessEnvironment() { super(); } private ProcessEnvironment(int capacity) { super(capacity); } // Only for use by System.getenv(String) static String getenv(String name) { // The original implementation used a native call to _wgetenv, // but it turns out that _wgetenv is only consistent with // GetEnvironmentStringsW (for non-ASCII) if `wmain' is used // instead of `main', even in a process created using // CREATE_UNICODE_ENVIRONMENT. Instead we perform the // case-insensitive comparison ourselves. At least this // guarantees that System.getenv().get(String) will be // consistent with System.getenv(String). return theCaseInsensitiveEnvironment.get(name); } // Only for use by System.getenv() static Map<String,String> getenv() { return theUnmodifiableEnvironment; } // Only for use by ProcessBuilder.environment() @SuppressWarnings("unchecked") static Map<String,String> environment() { return (Map<String,String>) theEnvironment.clone(); } // Only for use by ProcessBuilder.environment(String[] envp) static Map<String,String> emptyEnvironment(int capacity) { return new ProcessEnvironment(capacity); } private static native String environmentBlock(); // Only for use by ProcessImpl.start() String toEnvironmentBlock() { // Sort Unicode-case-insensitively by name List<Map.Entry<String,String>> list = new ArrayList<>(entrySet()); Collections.sort(list, entryComparator); StringBuilder sb = new StringBuilder(size()*30); int cmp = -1; // Some versions of MSVCRT.DLL require SystemRoot to be set. // So, we make sure that it is always set, even if not provided // by the caller. final String SYSTEMROOT = "SystemRoot"; for (Map.Entry<String,String> e : list) { String key = e.getKey(); String value = e.getValue(); if (cmp < 0 && (cmp = nameComparator.compare(key, SYSTEMROOT)) > 0) { // Not set, so add it here addToEnvIfSet(sb, SYSTEMROOT); } addToEnv(sb, key, value); } if (cmp < 0) { // Got to end of list and still not found addToEnvIfSet(sb, SYSTEMROOT); } if (sb.length() == 0) { // Environment was empty and SystemRoot not set in parent sb.append('\u0000'); } // Block is double NUL terminated sb.append('\u0000'); return sb.toString(); } // add the environment variable to the child, if it exists in parent private static void addToEnvIfSet(StringBuilder sb, String name) { String s = getenv(name); if (s != null) addToEnv(sb, name, s); } private static void addToEnv(StringBuilder sb, String name, String val) { sb.append(name).append('=').append(val).append('\u0000'); } static String toEnvironmentBlock(Map<String,String> map) { return map == null ? null : ((ProcessEnvironment)map).toEnvironmentBlock(); } }
⏎ java/lang/ProcessEnvironment.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, 203364👍, 0💬
Popular Posts:
How to download and install ojdbc11.jar for Oracle 21c? ojdbc11.jar for Oracle 21c is a Java JDBC Dr...
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module. JDK 11 RMI m...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...
Old version of xml-apis.jar. JAR File Size and Download Location: File name: xmlParserAPIs.jar File ...
JDK 11 jdk.internal.opt.jmod is the JMOD file for JDK 11 Internal Opt module. JDK 11 Internal Opt mo...