| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.lang; |
| |
| import java.io.BufferedInputStream; |
| import java.io.BufferedOutputStream; |
| import java.io.FileDescriptor; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.PrintStream; |
| import java.nio.channels.Channel; |
| import java.nio.channels.spi.SelectorProvider; |
| import java.security.Policy; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.PropertyPermission; |
| |
| /** |
| * Provides access to system-related information and resources including |
| * standard input and output. Enables clients to dynamically load native |
| * libraries. All methods of this class are accessed in a static way and the |
| * class itself can not be instantiated. |
| * |
| * @see Runtime |
| */ |
| public final class System { |
| |
| // The standard input, output, and error streams. |
| // Typically, these are connected to the shell which |
| // ran the Java program. |
| /** |
| * Default input stream. |
| */ |
| public static final InputStream in; |
| |
| /** |
| * Default output stream. |
| */ |
| public static final PrintStream out; |
| |
| /** |
| * Default error output stream. |
| */ |
| public static final PrintStream err; |
| |
| // Get a ref to the Runtime instance for faster lookup |
| private static final Runtime RUNTIME = Runtime.getRuntime(); |
| |
| /** |
| * The System Properties table. |
| */ |
| private static Properties systemProperties; |
| |
| // The System default SecurityManager |
| private static SecurityManager security; |
| |
| // Indicates whether the classes needed for |
| // permission checks was initialized or not |
| private static boolean security_initialized; |
| |
| // Initialize all the slots in System on first use. |
| static { |
| // Fill in the properties from the VM information. |
| ensureProperties(); |
| // Set up standard in, out, and err. |
| err = new String.ConsolePrintStream(new BufferedOutputStream(new FileOutputStream( |
| FileDescriptor.err))); |
| out = new String.ConsolePrintStream(new BufferedOutputStream(new FileOutputStream( |
| FileDescriptor.out))); |
| in = new BufferedInputStream(new FileInputStream(FileDescriptor.in)); |
| } |
| |
| /** |
| * Sets the standard input stream to the given user defined input stream. |
| * |
| * @param newIn |
| * the user defined input stream to set as the standard input |
| * stream. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPermission()} method does not allow the change of the |
| * stream. |
| */ |
| @SuppressWarnings("unused") |
| public static void setIn(InputStream newIn) { |
| SecurityManager secMgr = System.getSecurityManager(); |
| setFieldImpl("in", newIn); |
| } |
| |
| /** |
| * Sets the standard output stream to the given user defined output stream. |
| * |
| * @param newOut |
| * the user defined output stream to set as the standard output |
| * stream. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPermission()} method does not allow the change of the |
| * stream. |
| */ |
| @SuppressWarnings("unused") |
| public static void setOut(java.io.PrintStream newOut) { |
| SecurityManager secMgr = System.getSecurityManager(); |
| setFieldImpl("out", newOut); |
| } |
| |
| /** |
| * Sets the standard error output stream to the given user defined output |
| * stream. |
| * |
| * @param newErr |
| * the user defined output stream to set as the standard error |
| * output stream. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPermission()} method does not allow the change of the |
| * stream. |
| */ |
| @SuppressWarnings("unused") |
| public static void setErr(java.io.PrintStream newErr) { |
| SecurityManager secMgr = System.getSecurityManager(); |
| } |
| |
| /** |
| * Prevents this class from being instantiated. |
| */ |
| private System() { |
| } |
| |
| /** |
| * Copies the number of {@code length} elements of the Array {@code src} |
| * starting at the offset {@code srcPos} into the Array {@code dest} at |
| * the position {@code destPos}. |
| * |
| * @param src |
| * the source array to copy the content. |
| * @param srcPos |
| * the starting index of the content in {@code src}. |
| * @param dest |
| * the destination array to copy the data into. |
| * @param destPos |
| * the starting index for the copied content in {@code dest}. |
| * @param length |
| * the number of elements of the {@code array1} content they have |
| * to be copied. |
| */ |
| public static void arraycopy(Object src, int srcPos, Object dest, int destPos, |
| int length) { |
| // sending getClass() to both arguments will check for null |
| Class<?> type1 = src.getClass(); |
| Class<?> type2 = dest.getClass(); |
| if (!type1.isArray() || !type2.isArray()) { |
| throw new ArrayStoreException(); |
| } |
| Class<?> componentType1 = type1.getComponentType(); |
| Class<?> componentType2 = type2.getComponentType(); |
| if (!componentType1.isPrimitive()) { |
| if (componentType2.isPrimitive()) { |
| throw new ArrayStoreException(); |
| } |
| arraycopy((Object[]) src, srcPos, (Object[]) dest, destPos, length); |
| } else { |
| if (componentType2 != componentType1) { |
| throw new ArrayStoreException(); |
| } |
| if (componentType1 == Integer.TYPE) { |
| arraycopy((int[]) src, srcPos, (int[]) dest, destPos, length); |
| } else if (componentType1 == Byte.TYPE) { |
| arraycopy((byte[]) src, srcPos, (byte[]) dest, destPos, length); |
| } else if (componentType1 == Long.TYPE) { |
| arraycopy((long[]) src, srcPos, (long[]) dest, destPos, length); |
| } else if (componentType1 == Short.TYPE) { |
| arraycopy((short[]) src, srcPos, (short[]) dest, destPos, length); |
| } else if (componentType1 == Character.TYPE) { |
| arraycopy((char[]) src, srcPos, (char[]) dest, destPos, length); |
| } else if (componentType1 == Boolean.TYPE) { |
| arraycopy((boolean[]) src, srcPos, (boolean[]) dest, destPos, length); |
| } else if (componentType1 == Double.TYPE) { |
| arraycopy((double[]) src, srcPos, (double[]) dest, destPos, length); |
| } else if (componentType1 == Float.TYPE) { |
| arraycopy((float[]) src, srcPos, (float[]) dest, destPos, length); |
| } |
| } |
| } |
| |
| /** |
| * Private version of the arraycopy method (used by the jit for reference |
| * arraycopies) |
| */ |
| private static void arraycopy(Object[] A1, int offset1, Object[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(int[] A1, int offset1, int[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(byte[] A1, int offset1, byte[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(short[] A1, int offset1, short[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(long[] A1, int offset1, long[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(char[] A1, int offset1, char[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(boolean[] A1, int offset1, boolean[] A2, int offset2, |
| int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(double[] A1, int offset1, double[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Copies the contents of <code>A1</code> starting at offset |
| * <code>offset1</code> into <code>A2</code> starting at offset |
| * <code>offset2</code> for <code>length</code> elements. |
| * |
| * @param A1 the array to copy out of |
| * @param offset1 the starting index in array1 |
| * @param A2 the array to copy into |
| * @param offset2 the starting index in array2 |
| * @param length the number of elements in the array to copy |
| */ |
| private static void arraycopy(float[] A1, int offset1, float[] A2, int offset2, int length) { |
| if (offset1 >= 0 && offset2 >= 0 && length >= 0 && length <= A1.length - offset1 |
| && length <= A2.length - offset2) { |
| // Check if this is a forward or backwards arraycopy |
| if (A1 != A2 || offset1 > offset2 || offset1 + length <= offset2) { |
| for (int i = 0; i < length; ++i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } else { |
| for (int i = length - 1; i >= 0; --i) { |
| A2[offset2 + i] = A1[offset1 + i]; |
| } |
| } |
| } else { |
| throw new ArrayIndexOutOfBoundsException(); |
| } |
| } |
| |
| /** |
| * Returns the current system time in milliseconds since January 1, 1970 |
| * 00:00:00 UTC. This method shouldn't be used for measuring timeouts or |
| * other elapsed time measurements, as changing the system time can affect |
| * the results. |
| * |
| * @return the local system time in milliseconds. |
| */ |
| public static native long currentTimeMillis(); |
| |
| /** |
| * Returns the current timestamp of the most precise timer available on the |
| * local system. This timestamp can only be used to measure an elapsed |
| * period by comparing it against another timestamp. It cannot be used as a |
| * very exact system time expression. |
| * |
| * @return the current timestamp in nanoseconds. |
| */ |
| public static native long nanoTime(); |
| |
| private static final int InitLocale = 0; |
| |
| private static final int PlatformEncoding = 1; |
| |
| private static final int FileEncoding = 2; |
| |
| private static final int OSEncoding = 3; |
| |
| /** |
| * If systemProperties is unset, then create a new one based on the values |
| * provided by the virtual machine. |
| */ |
| private static void ensureProperties() { |
| systemProperties = new Properties(); |
| |
| String platformEncoding = null; |
| String fileEncoding, osEncoding = null; |
| String definedFileEncoding = getEncoding(FileEncoding); |
| String definedOSEncoding = getEncoding(OSEncoding); |
| if (definedFileEncoding != null) { |
| fileEncoding = definedFileEncoding; |
| // if file.encoding is defined, and os.encoding is not, use the |
| // detected |
| // platform encoding for os.encoding |
| if (definedOSEncoding == null) { |
| platformEncoding = getEncoding(PlatformEncoding); |
| osEncoding = platformEncoding; |
| } else { |
| getEncoding(InitLocale); |
| } |
| } else { |
| platformEncoding = getEncoding(PlatformEncoding); |
| fileEncoding = platformEncoding; |
| } |
| // if os.encoding is not defined, file.encoding will be used |
| if (osEncoding == null) { |
| osEncoding = definedOSEncoding; |
| } |
| if (osEncoding != null) { |
| systemProperties.put("os.encoding", osEncoding); |
| } |
| |
| systemProperties.put("file.encoding", fileEncoding); |
| |
| systemProperties.put("java.version", "1.5 subset"); |
| systemProperties.put("java.specification.version", "1.5"); |
| |
| systemProperties.put("java.specification.vendor", "Sun Microsystems Inc."); |
| systemProperties.put("java.specification.name", "Java Platform API Specification"); |
| |
| systemProperties.put("com.ibm.oti.configuration", "clear"); |
| systemProperties.put("com.ibm.oti.configuration.dir", "jclClear"); |
| |
| String[] list = getPropertyList(); |
| for (int i = 0; i < list.length; i += 2) { |
| String key = list[i]; |
| if (key == null) { |
| break; |
| } |
| systemProperties.put(key, list[i + 1]); |
| } |
| |
| String consoleEncoding = (String) systemProperties.get("console.encoding"); |
| if (consoleEncoding == null) { |
| if (platformEncoding == null) { |
| platformEncoding = getEncoding(PlatformEncoding); |
| } |
| consoleEncoding = platformEncoding; |
| systemProperties.put("console.encoding", consoleEncoding); |
| } |
| |
| } |
| |
| /** |
| * Causes the virtual machine to stop running and the program to exit. If |
| * {@link #runFinalizersOnExit(boolean)} has been previously invoked with a |
| * {@code true} argument, then all all objects will be properly |
| * garbage-collected and finalized first. |
| * |
| * @param code |
| * the return code. |
| * @throws SecurityException |
| * if the running thread has not enough permission to exit the |
| * virtual machine. |
| * @see SecurityManager#checkExit |
| */ |
| public static void exit(int code) { |
| RUNTIME.exit(code); |
| } |
| |
| /** |
| * Indicates to the virtual machine that it would be a good time to run the |
| * garbage collector. Note that this is a hint only. There is no guarantee |
| * that the garbage collector will actually be run. |
| */ |
| public static void gc() { |
| RUNTIME.gc(); |
| } |
| |
| /** |
| * Returns the value of the environment variable with the given name {@code |
| * var}. |
| * |
| * @param name |
| * the name of the environment variable. |
| * @return the value of the specified environment variable or {@code null} |
| * if no variable exists with the given name. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPermission()} method does not allow the querying of |
| * single environment variables. |
| */ |
| public static String getenv(String name) { |
| if (name == null) { |
| throw new NullPointerException(); |
| } |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPermission(new RuntimePermission("getenv." + name)); |
| } |
| throw new Error(); |
| } |
| |
| /** |
| * Returns an unmodifiable map of all available environment variables. |
| * |
| * @return the map representing all environment variables. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPermission()} method does not allow the querying of |
| * all environment variables. |
| */ |
| public static Map<String, String> getenv() { |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPermission(new RuntimePermission("getenv.*")); |
| } |
| throw new Error(); |
| } |
| |
| /** |
| * Returns the inherited channel from the creator of the current virtual |
| * machine. |
| * |
| * @return the inherited {@link Channel} or {@code null} if none exists. |
| * @throws IOException |
| * if an I/O error occurred. |
| * @see SelectorProvider |
| * @see SelectorProvider#inheritedChannel() |
| */ |
| public static Channel inheritedChannel() throws IOException { |
| return SelectorProvider.provider().inheritedChannel(); |
| } |
| |
| /** |
| * Returns the system properties. Note that this is not a copy, so that |
| * changes made to the returned Properties object will be reflected in |
| * subsequent calls to getProperty and getProperties. |
| * |
| * @return the system properties. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPropertiesAccess()} method does not allow the operation. |
| */ |
| public static Properties getProperties() { |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPropertiesAccess(); |
| } |
| return systemProperties; |
| } |
| |
| /** |
| * Returns the system properties without any security checks. This is used |
| * for access from within java.lang. |
| * |
| * @return the system properties |
| */ |
| static Properties internalGetProperties() { |
| return systemProperties; |
| } |
| |
| /** |
| * Returns the value of a particular system property or {@code null} if no |
| * such property exists. |
| * <p> |
| * The properties currently provided by the virtual machine are: |
| * |
| * <pre> |
| * java.vendor.url |
| * java.class.path |
| * user.home |
| * java.class.version |
| * os.version |
| * java.vendor |
| * user.dir |
| * user.timezone |
| * path.separator |
| * os.name |
| * os.arch |
| * line.separator |
| * file.separator |
| * user.name |
| * java.version |
| * java.home |
| * </pre> |
| * |
| * @param prop |
| * the name of the system property to look up. |
| * @return the value of the specified system property or {@code null} if the |
| * property doesn't exist. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPropertyAccess()} method does not allow the operation. |
| */ |
| public static String getProperty(String prop) { |
| return getProperty(prop, null); |
| } |
| |
| /** |
| * Returns the value of a particular system property. The {@code |
| * defaultValue} will be returned if no such property has been found. |
| * |
| * @param prop |
| * the name of the system property to look up. |
| * @param defaultValue |
| * the return value if the system property with the given name |
| * does not exist. |
| * @return the value of the specified system property or the {@code |
| * defaultValue} if the property does not exist. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPropertyAccess()} method does not allow the operation. |
| */ |
| public static String getProperty(String prop, String defaultValue) { |
| if (prop.length() == 0) { |
| throw new IllegalArgumentException(); |
| } |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPropertyAccess(prop); |
| } |
| return systemProperties.getProperty(prop, defaultValue); |
| } |
| |
| /** |
| * Sets the value of a particular system property. |
| * |
| * @param prop |
| * the name of the system property to be changed. |
| * @param value |
| * the value to associate with the given property {@code prop}. |
| * @return the old value of the property or {@code null} if the property |
| * didn't exist. |
| * @throws SecurityException |
| * if a security manager exists and write access to the |
| * specified property is not allowed. |
| */ |
| public static String setProperty(String prop, String value) { |
| if (prop.length() == 0) { |
| throw new IllegalArgumentException(); |
| } |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPermission(new PropertyPermission(prop, "write")); |
| } |
| return (String) systemProperties.setProperty(prop, value); |
| } |
| |
| /** |
| * Removes a specific system property. |
| * |
| * @param key |
| * the name of the system property to be removed. |
| * @return the property value or {@code null} if the property didn't exist. |
| * @throws NullPointerException |
| * if the argument {@code key} is {@code null}. |
| * @throws IllegalArgumentException |
| * if the argument {@code key} is empty. |
| * @throws SecurityException |
| * if a security manager exists and write access to the |
| * specified property is not allowed. |
| * @since 1.5 |
| */ |
| public static String clearProperty(String key) { |
| if (key == null) { |
| throw new NullPointerException(); |
| } |
| if (key.length() == 0) { |
| throw new IllegalArgumentException(); |
| } |
| |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPermission(new PropertyPermission(key, "write")); |
| } |
| return (String) systemProperties.remove(key); |
| } |
| |
| /** |
| * Answers an array of Strings containing key..value pairs (in consecutive |
| * array elements) which represent the starting values for the system |
| * properties as provided by the virtual machine. |
| * |
| * @return the default values for the system properties. |
| */ |
| private static native String[] getPropertyList(); |
| |
| /** |
| * Return the requested encoding. 0 - initialize locale 1 - detected |
| * platform encoding 2 - command line defined file.encoding 3 - command line |
| * defined os.encoding |
| */ |
| private static native String getEncoding(int type); |
| |
| /** |
| * Returns the active security manager. |
| * |
| * @return the system security manager object. |
| */ |
| public static SecurityManager getSecurityManager() { |
| return security; |
| } |
| |
| /** |
| * Returns an integer hash code for the parameter. The hash code returned is |
| * the same one that would be returned by the method {@code |
| * java.lang.Object.hashCode()}, whether or not the object's class has |
| * overridden hashCode(). The hash code for {@code null} is {@code 0}. |
| * |
| * @param anObject |
| * the object to calculate the hash code. |
| * @return the hash code for the given object. |
| * @see java.lang.Object#hashCode |
| */ |
| public static native int identityHashCode(Object anObject); |
| |
| /** |
| * Loads the specified file as a dynamic library. |
| * |
| * @param pathName |
| * the path of the file to be loaded. |
| * @throws SecurityException |
| * if the library was not allowed to be loaded. |
| */ |
| public static void load(String pathName) { |
| SecurityManager smngr = System.getSecurityManager(); |
| if (smngr != null) { |
| smngr.checkLink(pathName); |
| } |
| ClassLoader.loadLibraryWithPath(pathName, ClassLoader.callerClassLoader(), null); |
| } |
| |
| /** |
| * Loads and links the shared library with the given name {@code libName}. |
| * The file will be searched in the default directory for shared libraries |
| * of the local system. |
| * |
| * @param libName |
| * the name of the library to load. |
| * @throws UnsatisfiedLinkError |
| * if the library could not be loaded. |
| * @throws SecurityException |
| * if the library was not allowed to be loaded. |
| */ |
| public static void loadLibrary(String libName) { |
| ClassLoader.loadLibraryWithClassLoader(libName, ClassLoader.callerClassLoader()); |
| } |
| |
| /** |
| * Provides a hint to the virtual machine that it would be useful to attempt |
| * to perform any outstanding object finalizations. |
| */ |
| public static void runFinalization() { |
| RUNTIME.runFinalization(); |
| } |
| |
| /** |
| * Ensures that, when the virtual machine is about to exit, all objects are |
| * finalized. Note that all finalization which occurs when the system is |
| * exiting is performed after all running threads have been terminated. |
| * |
| * @param flag |
| * the flag determines if finalization on exit is enabled. |
| * @deprecated this method is unsafe. |
| */ |
| @SuppressWarnings("deprecation") |
| @Deprecated |
| public static void runFinalizersOnExit(boolean flag) { |
| Runtime.runFinalizersOnExit(flag); |
| } |
| |
| /** |
| * Sets all system properties. Note that the object which is passed in |
| * not copied, so that subsequent changes made to the object will be |
| * reflected in calls to getProperty and getProperties. |
| * |
| * @param p |
| * the new system property. |
| * @throws SecurityException |
| * if a {@link SecurityManager} is installed and its {@code |
| * checkPropertiesAccess()} method does not allow the operation. |
| */ |
| public static void setProperties(Properties p) { |
| SecurityManager secMgr = System.getSecurityManager(); |
| if (secMgr != null) { |
| secMgr.checkPropertiesAccess(); |
| } |
| if (p == null) { |
| ensureProperties(); |
| } else { |
| systemProperties = p; |
| } |
| } |
| |
| /** |
| * Sets the active security manager. Note that once the security manager has |
| * been set, it can not be changed. Attempts to do that will cause a |
| * security exception. |
| * |
| * @param sm |
| * the new security manager. |
| * |
| * @throws SecurityException |
| * if the security manager has already been set and if its |
| * checkPermission method does not allow to redefine the |
| * security manager. |
| */ |
| public static void setSecurityManager(final SecurityManager sm) { |
| if (!security_initialized) { |
| try { |
| // Preload and initialize Policy implementation classes |
| // otherwise we could go recursive |
| Policy.getPolicy(); |
| } catch (Exception e) { |
| } |
| security_initialized = true; |
| } |
| |
| security = sm; |
| } |
| |
| /** |
| * Returns the platform specific file name format for the shared library |
| * named by the argument. |
| * |
| * @param userLibName |
| * the name of the library to look up. |
| * @return the platform specific filename for the library |
| */ |
| public static native String mapLibraryName(String userLibName); |
| |
| /** |
| * Sets the value of the named static field in the receiver to the passed in |
| * argument. |
| * |
| * @param fieldName |
| * the name of the field to set, one of in, out, or err |
| * @param stream |
| * the new value of the field |
| */ |
| private static native void setFieldImpl(String fieldName, Object stream); |
| |
| } |
