Mark as release
[official-gcc.git] / libjava / java / lang / System.java
blob6b125c90a2a006ebe4ac3b611489696df3e8e76e
1 /* System.java -- useful methods to interface with the system
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 This file is part of GNU Classpath.
7 GNU Classpath is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Classpath is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Classpath; see the file COPYING. If not, write to the
19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301 USA.
22 Linking this library statically or dynamically with other modules is
23 making a combined work based on this library. Thus, the terms and
24 conditions of the GNU General Public License cover the whole
25 combination.
27 As a special exception, the copyright holders of this library give you
28 permission to link this library with independent modules to produce an
29 executable, regardless of the license terms of these independent
30 modules, and to copy and distribute the resulting executable under
31 terms of your choice, provided that you also meet, for each linked
32 independent module, the terms and conditions of the license of that
33 module. An independent module is a module which is not derived from
34 or based on this library. If you modify this library, you may extend
35 this exception to your version of the library, but you are not
36 obligated to do so. If you do not wish to do so, delete this
37 exception statement from your version. */
40 package java.lang;
42 import gnu.classpath.SystemProperties;
44 import java.io.BufferedInputStream;
45 import java.io.BufferedOutputStream;
46 import java.io.FileDescriptor;
47 import java.io.FileInputStream;
48 import java.io.FileOutputStream;
49 import java.io.InputStream;
50 import java.io.PrintStream;
51 import java.util.Properties;
52 import java.util.PropertyPermission;
54 /**
55 * System represents system-wide resources; things that represent the
56 * general environment. As such, all methods are static.
58 * @author John Keiser
59 * @author Eric Blake (ebb9@email.byu.edu)
60 * @since 1.0
61 * @status still missing 1.4 functionality
63 public final class System
65 // WARNING: System is a CORE class in the bootstrap cycle. See the comments
66 // in vm/reference/java/lang/Runtime for implications of this fact.
68 /**
69 * The standard InputStream. This is assigned at startup and starts its
70 * life perfectly valid. Although it is marked final, you can change it
71 * using {@link #setIn(InputStream)} through some hefty VM magic.
73 * <p>This corresponds to the C stdin and C++ cin variables, which
74 * typically input from the keyboard, but may be used to pipe input from
75 * other processes or files. That should all be transparent to you,
76 * however.
78 public static final InputStream in
79 = new BufferedInputStream(new FileInputStream(FileDescriptor.in));
80 /**
81 * The standard output PrintStream. This is assigned at startup and
82 * starts its life perfectly valid. Although it is marked final, you can
83 * change it using {@link #setOut(PrintStream)} through some hefty VM magic.
85 * <p>This corresponds to the C stdout and C++ cout variables, which
86 * typically output normal messages to the screen, but may be used to pipe
87 * output to other processes or files. That should all be transparent to
88 * you, however.
90 public static final PrintStream out
91 = new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true);
92 /**
93 * The standard output PrintStream. This is assigned at startup and
94 * starts its life perfectly valid. Although it is marked final, you can
95 * change it using {@link #setErr(PrintStream)} through some hefty VM magic.
97 * <p>This corresponds to the C stderr and C++ cerr variables, which
98 * typically output error messages to the screen, but may be used to pipe
99 * output to other processes or files. That should all be transparent to
100 * you, however.
102 public static final PrintStream err
103 = new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true);
106 * This class is uninstantiable.
108 private System()
113 * Set {@link #in} to a new InputStream. This uses some VM magic to change
114 * a "final" variable, so naturally there is a security check,
115 * <code>RuntimePermission("setIO")</code>.
117 * @param in the new InputStream
118 * @throws SecurityException if permission is denied
119 * @since 1.1
121 public static void setIn(InputStream in)
123 SecurityManager sm = SecurityManager.current; // Be thread-safe.
124 if (sm != null)
125 sm.checkPermission(new RuntimePermission("setIO"));
126 setIn0(in);
130 * Set {@link #out} to a new PrintStream. This uses some VM magic to change
131 * a "final" variable, so naturally there is a security check,
132 * <code>RuntimePermission("setIO")</code>.
134 * @param out the new PrintStream
135 * @throws SecurityException if permission is denied
136 * @since 1.1
138 public static void setOut(PrintStream out)
140 SecurityManager sm = SecurityManager.current; // Be thread-safe.
141 if (sm != null)
142 sm.checkPermission(new RuntimePermission("setIO"));
144 setOut0(out);
148 * Set {@link #err} to a new PrintStream. This uses some VM magic to change
149 * a "final" variable, so naturally there is a security check,
150 * <code>RuntimePermission("setIO")</code>.
152 * @param err the new PrintStream
153 * @throws SecurityException if permission is denied
154 * @since 1.1
156 public static void setErr(PrintStream err)
158 SecurityManager sm = SecurityManager.current; // Be thread-safe.
159 if (sm != null)
160 sm.checkPermission(new RuntimePermission("setIO"));
161 setErr0(err);
165 * Set the current SecurityManager. If a security manager already exists,
166 * then <code>RuntimePermission("setSecurityManager")</code> is checked
167 * first. Since this permission is denied by the default security manager,
168 * setting the security manager is often an irreversible action.
170 * @param sm the new SecurityManager
171 * @throws SecurityException if permission is denied
173 public static synchronized void setSecurityManager(SecurityManager sm)
175 // Implementation note: the field lives in SecurityManager because of
176 // bootstrap initialization issues. This method is synchronized so that
177 // no other thread changes it to null before this thread makes the change.
178 if (SecurityManager.current != null)
179 SecurityManager.current.checkPermission
180 (new RuntimePermission("setSecurityManager"));
181 SecurityManager.current = sm;
185 * Get the current SecurityManager. If the SecurityManager has not been
186 * set yet, then this method returns null.
188 * @return the current SecurityManager, or null
190 public static SecurityManager getSecurityManager()
192 return SecurityManager.current;
196 * Get the current time, measured in the number of milliseconds from the
197 * beginning of Jan. 1, 1970. This is gathered from the system clock, with
198 * any attendant incorrectness (it may be timezone dependent).
200 * @return the current time
201 * @see java.util.Date
203 public static native long currentTimeMillis();
206 * Get the current time, measured in nanoseconds. The result is as
207 * precise as possible, and is measured against a fixed epoch.
208 * However, unlike currentTimeMillis(), the epoch chosen is
209 * arbitrary and may vary by platform, etc.
210 * @since 1.5
212 public static native long nanoTime();
215 * Copy one array onto another from <code>src[srcStart]</code> ...
216 * <code>src[srcStart+len-1]</code> to <code>dest[destStart]</code> ...
217 * <code>dest[destStart+len-1]</code>. First, the arguments are validated:
218 * neither array may be null, they must be of compatible types, and the
219 * start and length must fit within both arrays. Then the copying starts,
220 * and proceeds through increasing slots. If src and dest are the same
221 * array, this will appear to copy the data to a temporary location first.
222 * An ArrayStoreException in the middle of copying will leave earlier
223 * elements copied, but later elements unchanged.
225 * @param src the array to copy elements from
226 * @param srcStart the starting position in src
227 * @param dest the array to copy elements to
228 * @param destStart the starting position in dest
229 * @param len the number of elements to copy
230 * @throws NullPointerException if src or dest is null
231 * @throws ArrayStoreException if src or dest is not an array, if they are
232 * not compatible array types, or if an incompatible runtime type
233 * is stored in dest
234 * @throws IndexOutOfBoundsException if len is negative, or if the start or
235 * end copy position in either array is out of bounds
237 public static native void arraycopy(Object src, int srcStart,
238 Object dest, int destStart, int len);
241 * Get a hash code computed by the VM for the Object. This hash code will
242 * be the same as Object's hashCode() method. It is usually some
243 * convolution of the pointer to the Object internal to the VM. It
244 * follows standard hash code rules, in that it will remain the same for a
245 * given Object for the lifetime of that Object.
247 * @param o the Object to get the hash code for
248 * @return the VM-dependent hash code for this Object
249 * @since 1.1
251 public static native int identityHashCode(Object o);
254 * Get all the system properties at once. A security check may be performed,
255 * <code>checkPropertiesAccess</code>. Note that a security manager may
256 * allow getting a single property, but not the entire group.
258 * <p>The required properties include:
259 * <dl>
260 * <dt>java.version</dt> <dd>Java version number</dd>
261 * <dt>java.vendor</dt> <dd>Java vendor specific string</dd>
262 * <dt>java.vendor.url</dt> <dd>Java vendor URL</dd>
263 * <dt>java.home</dt> <dd>Java installation directory</dd>
264 * <dt>java.vm.specification.version</dt> <dd>VM Spec version</dd>
265 * <dt>java.vm.specification.vendor</dt> <dd>VM Spec vendor</dd>
266 * <dt>java.vm.specification.name</dt> <dd>VM Spec name</dd>
267 * <dt>java.vm.version</dt> <dd>VM implementation version</dd>
268 * <dt>java.vm.vendor</dt> <dd>VM implementation vendor</dd>
269 * <dt>java.vm.name</dt> <dd>VM implementation name</dd>
270 * <dt>java.specification.version</dt> <dd>Java Runtime Environment version</dd>
271 * <dt>java.specification.vendor</dt> <dd>Java Runtime Environment vendor</dd>
272 * <dt>java.specification.name</dt> <dd>Java Runtime Environment name</dd>
273 * <dt>java.class.version</dt> <dd>Java class version number</dd>
274 * <dt>java.class.path</dt> <dd>Java classpath</dd>
275 * <dt>java.library.path</dt> <dd>Path for finding Java libraries</dd>
276 * <dt>java.io.tmpdir</dt> <dd>Default temp file path</dd>
277 * <dt>java.compiler</dt> <dd>Name of JIT to use</dd>
278 * <dt>java.ext.dirs</dt> <dd>Java extension path</dd>
279 * <dt>os.name</dt> <dd>Operating System Name</dd>
280 * <dt>os.arch</dt> <dd>Operating System Architecture</dd>
281 * <dt>os.version</dt> <dd>Operating System Version</dd>
282 * <dt>file.separator</dt> <dd>File separator ("/" on Unix)</dd>
283 * <dt>path.separator</dt> <dd>Path separator (":" on Unix)</dd>
284 * <dt>line.separator</dt> <dd>Line separator ("\n" on Unix)</dd>
285 * <dt>user.name</dt> <dd>User account name</dd>
286 * <dt>user.home</dt> <dd>User home directory</dd>
287 * <dt>user.dir</dt> <dd>User's current working directory</dd>
288 * </dl>
290 * In addition, gnu defines several other properties, where ? stands for
291 * each character in '0' through '9':
292 * <dl>
293 * <dt>gnu.classpath.home</dt> <dd>Path to the classpath libraries.</dd>
294 * <dt>gnu.classpath.version</dt> <dd>Version of the classpath libraries.</dd>
295 * <dt>gnu.classpath.vm.shortname</dt> <dd>Succinct version of the VM name;
296 * used for finding property files in file system</dd>
297 * <dt>gnu.classpath.home.url</dt> <dd> Base URL; used for finding
298 * property files in file system</dd>
299 * <dt>gnu.cpu.endian</dt> <dd>big or little</dd>
300 * <dt>gnu.java.io.encoding_scheme_alias.ISO-8859-?</dt> <dd>8859_?</dd>
301 * <dt>gnu.java.io.encoding_scheme_alias.iso-8859-?</dt> <dd>8859_?</dd>
302 * <dt>gnu.java.io.encoding_scheme_alias.iso8859_?</dt> <dd>8859_?</dd>
303 * <dt>gnu.java.io.encoding_scheme_alias.iso-latin-_?</dt> <dd>8859_?</dd>
304 * <dt>gnu.java.io.encoding_scheme_alias.latin?</dt> <dd>8859_?</dd>
305 * <dt>gnu.java.io.encoding_scheme_alias.UTF-8</dt> <dd>UTF8</dd>
306 * <dt>gnu.java.io.encoding_scheme_alias.utf-8</dt> <dd>UTF8</dd>
307 * </dl>
309 * @return the system properties, will never be null
310 * @throws SecurityException if permission is denied
312 public static Properties getProperties()
314 SecurityManager sm = SecurityManager.current; // Be thread-safe.
315 if (sm != null)
316 sm.checkPropertiesAccess();
317 return SystemProperties.getProperties();
321 * Set all the system properties at once. A security check may be performed,
322 * <code>checkPropertiesAccess</code>. Note that a security manager may
323 * allow setting a single property, but not the entire group. An argument
324 * of null resets the properties to the startup default.
326 * @param properties the new set of system properties
327 * @throws SecurityException if permission is denied
329 public static void setProperties(Properties properties)
331 SecurityManager sm = SecurityManager.current; // Be thread-safe.
332 if (sm != null)
333 sm.checkPropertiesAccess();
334 SystemProperties.setProperties(properties);
338 * Get a single system property by name. A security check may be performed,
339 * <code>checkPropertyAccess(key)</code>.
341 * @param key the name of the system property to get
342 * @return the property, or null if not found
343 * @throws SecurityException if permission is denied
344 * @throws NullPointerException if key is null
345 * @throws IllegalArgumentException if key is ""
347 public static String getProperty(String key)
349 SecurityManager sm = SecurityManager.current; // Be thread-safe.
350 if (sm != null)
351 sm.checkPropertyAccess(key);
352 else if (key.length() == 0)
353 throw new IllegalArgumentException("key can't be empty");
354 return SystemProperties.getProperty(key);
358 * Get a single system property by name. A security check may be performed,
359 * <code>checkPropertyAccess(key)</code>.
361 * @param key the name of the system property to get
362 * @param def the default
363 * @return the property, or def if not found
364 * @throws SecurityException if permission is denied
365 * @throws NullPointerException if key is null
366 * @throws IllegalArgumentException if key is ""
368 public static String getProperty(String key, String def)
370 SecurityManager sm = SecurityManager.current; // Be thread-safe.
371 if (sm != null)
372 sm.checkPropertyAccess(key);
373 return SystemProperties.getProperty(key, def);
377 * Set a single system property by name. A security check may be performed,
378 * <code>checkPropertyAccess(key, "write")</code>.
380 * @param key the name of the system property to set
381 * @param value the new value
382 * @return the previous value, or null
383 * @throws SecurityException if permission is denied
384 * @throws NullPointerException if key is null
385 * @throws IllegalArgumentException if key is ""
386 * @since 1.2
388 public static String setProperty(String key, String value)
390 SecurityManager sm = SecurityManager.current; // Be thread-safe.
391 if (sm != null)
392 sm.checkPermission(new PropertyPermission(key, "write"));
393 return SystemProperties.setProperty(key, value);
397 * Gets the value of an environment variable.
399 * @param name the name of the environment variable
400 * @return the string value of the variable or null when the
401 * environment variable is not defined.
402 * @throws NullPointerException
403 * @throws SecurityException if permission is denied
404 * @since 1.5
405 * @specnote This method was deprecated in some JDK releases, but
406 * was restored in 1.5.
408 public static String getenv(String name)
410 if (name == null)
411 throw new NullPointerException();
412 SecurityManager sm = SecurityManager.current; // Be thread-safe.
413 if (sm != null)
414 sm.checkPermission(new RuntimePermission("getenv." + name));
415 return getenv0(name);
419 * Terminate the Virtual Machine. This just calls
420 * <code>Runtime.getRuntime().exit(status)</code>, and never returns.
421 * Obviously, a security check is in order, <code>checkExit</code>.
423 * @param status the exit status; by convention non-zero is abnormal
424 * @throws SecurityException if permission is denied
425 * @see Runtime#exit(int)
427 public static void exit(int status)
429 Runtime.getRuntime().exit(status);
433 * Calls the garbage collector. This is only a hint, and it is up to the
434 * implementation what this hint suggests, but it usually causes a
435 * best-effort attempt to reclaim unused memory from discarded objects.
436 * This calls <code>Runtime.getRuntime().gc()</code>.
438 * @see Runtime#gc()
440 public static void gc()
442 Runtime.getRuntime().gc();
446 * Runs object finalization on pending objects. This is only a hint, and
447 * it is up to the implementation what this hint suggests, but it usually
448 * causes a best-effort attempt to run finalizers on all objects ready
449 * to be reclaimed. This calls
450 * <code>Runtime.getRuntime().runFinalization()</code>.
452 * @see Runtime#runFinalization()
454 public static void runFinalization()
456 Runtime.getRuntime().runFinalization();
460 * Tell the Runtime whether to run finalization before exiting the
461 * JVM. This is inherently unsafe in multi-threaded applications,
462 * since it can force initialization on objects which are still in use
463 * by live threads, leading to deadlock; therefore this is disabled by
464 * default. There may be a security check, <code>checkExit(0)</code>. This
465 * calls <code>Runtime.getRuntime().runFinalizersOnExit()</code>.
467 * @param finalizeOnExit whether to run finalizers on exit
468 * @throws SecurityException if permission is denied
469 * @see Runtime#runFinalizersOnExit()
470 * @since 1.1
471 * @deprecated never rely on finalizers to do a clean, thread-safe,
472 * mop-up from your code
474 public static void runFinalizersOnExit(boolean finalizeOnExit)
476 Runtime.getRuntime().runFinalizersOnExit(finalizeOnExit);
480 * Load a code file using its explicit system-dependent filename. A security
481 * check may be performed, <code>checkLink</code>. This just calls
482 * <code>Runtime.getRuntime().load(filename)</code>.
484 * <p>
485 * The library is loaded using the class loader associated with the
486 * class associated with the invoking method.
488 * @param filename the code file to load
489 * @throws SecurityException if permission is denied
490 * @throws UnsatisfiedLinkError if the file cannot be loaded
491 * @see Runtime#load(String)
493 public static void load(String filename)
495 Runtime.getRuntime().load(filename);
499 * Load a library using its explicit system-dependent filename. A security
500 * check may be performed, <code>checkLink</code>. This just calls
501 * <code>Runtime.getRuntime().load(filename)</code>.
503 * <p>
504 * The library is loaded using the class loader associated with the
505 * class associated with the invoking method.
507 * @param libname the library file to load
508 * @throws SecurityException if permission is denied
509 * @throws UnsatisfiedLinkError if the file cannot be loaded
510 * @see Runtime#load(String)
512 public static void loadLibrary(String libname)
514 Runtime.getRuntime().loadLibrary(libname);
518 * Convert a library name to its platform-specific variant.
520 * @param libname the library name, as used in <code>loadLibrary</code>
521 * @return the platform-specific mangling of the name
522 * @since 1.2
524 public static String mapLibraryName(String libname)
526 // XXX Fix this!!!!
527 return Runtime.nativeGetLibname("", libname);
531 * Set {@link #in} to a new InputStream.
533 * @param in the new InputStream
534 * @see #setIn(InputStream)
536 private static native void setIn0(InputStream in);
539 * Set {@link #out} to a new PrintStream.
541 * @param out the new PrintStream
542 * @see #setOut(PrintStream)
544 private static native void setOut0(PrintStream out);
547 * Set {@link #err} to a new PrintStream.
549 * @param err the new PrintStream
550 * @see #setErr(PrintStream)
552 private static native void setErr0(PrintStream err);
555 * Gets the value of an environment variable.
557 * @see #getenv(String)
559 static native String getenv0(String name);
560 } // class System