libjava/java/lang/System.java

   1 /* System.java -- useful methods to interface with the system
   2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU Classpath.
   6
   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.
  11
  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.
  16
  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., 59 Temple Place, Suite 330, Boston, MA
  20 02111-1307 USA.
  21
  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.
  26
  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. */
  38
  39
  40 package java.lang;
  41
  42 import gnu.classpath.SystemProperties;
  43
  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;
  53
  54 /**
  55  * System represents system-wide resources; things that represent the
  56  * general environment.  As such, all methods are static.
  57  *
  58  * @author John Keiser
  59  * @author Eric Blake (ebb9@email.byu.edu)
  60  * @since 1.0
  61  * @status still missing 1.4 functionality
  62  */
  63 public final class System
  64 {
  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.
  67
  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.
  72    *
  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.
  77    */
  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.
  84    *
  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.
  89    */
  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.
  96    *
  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.
 101    */
 102   public static final PrintStream err
 103     = new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true);
 104
 105   /**
 106    * This class is uninstantiable.
 107    */
 108   private System()
 109   {
 110   }
 111
 112   /**
 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>.
 116    *
 117    * @param in the new InputStream
 118    * @throws SecurityException if permission is denied
 119    * @since 1.1
 120    */
 121   public static void setIn(InputStream in)
 122   {
 123     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 124     if (sm != null)
 125       sm.checkPermission(new RuntimePermission("setIO"));
 126     setIn0(in);
 127   }
 128
 129   /**
 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>.
 133    *
 134    * @param out the new PrintStream
 135    * @throws SecurityException if permission is denied
 136    * @since 1.1
 137    */
 138   public static void setOut(PrintStream out)
 139   {
 140     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 141     if (sm != null)
 142       sm.checkPermission(new RuntimePermission("setIO"));
 143
 144     setOut0(out);
 145   }
 146
 147   /**
 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>.
 151    *
 152    * @param err the new PrintStream
 153    * @throws SecurityException if permission is denied
 154    * @since 1.1
 155    */
 156   public static void setErr(PrintStream err)
 157   {
 158     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 159     if (sm != null)
 160       sm.checkPermission(new RuntimePermission("setIO"));
 161     setErr0(err);
 162   }
 163
 164   /**
 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.
 169    *
 170    * <STRONG>Spec Note:</STRONG> Don't ask me, I didn't write it.  It looks
 171    * pretty vulnerable; whoever gets to the gate first gets to set the policy.
 172    * There is probably some way to set the original security manager as a
 173    * command line argument to the VM, but I don't know it.
 174    *
 175    * @param sm the new SecurityManager
 176    * @throws SecurityException if permission is denied
 177    */
 178   public static synchronized void setSecurityManager(SecurityManager sm)
 179   {
 180     // Implementation note: the field lives in Runtime because of bootstrap
 181     // initialization issues. This method is synchronized so that no other
 182     // thread changes it to null before this thread makes the change.
 183     if (Runtime.securityManager != null)
 184       Runtime.securityManager.checkPermission
 185         (new RuntimePermission("setSecurityManager"));
 186     Runtime.securityManager = sm;
 187   }
 188
 189   /**
 190    * Get the current SecurityManager. If the SecurityManager has not been
 191    * set yet, then this method returns null.
 192    *
 193    * @return the current SecurityManager, or null
 194    */
 195   public static SecurityManager getSecurityManager()
 196   {
 197     // Implementation note: the field lives in Runtime because of bootstrap
 198     // initialization issues.
 199     return Runtime.securityManager;
 200   }
 201
 202   /**
 203    * Get the current time, measured in the number of milliseconds from the
 204    * beginning of Jan. 1, 1970. This is gathered from the system clock, with
 205    * any attendant incorrectness (it may be timezone dependent).
 206    *
 207    * @return the current time
 208    * @see java.util.Date
 209    */
 210   public static native long currentTimeMillis();
 211
 212   /**
 213    * Copy one array onto another from <code>src[srcStart]</code> ...
 214    * <code>src[srcStart+len-1]</code> to <code>dest[destStart]</code> ...
 215    * <code>dest[destStart+len-1]</code>. First, the arguments are validated:
 216    * neither array may be null, they must be of compatible types, and the
 217    * start and length must fit within both arrays. Then the copying starts,
 218    * and proceeds through increasing slots.  If src and dest are the same
 219    * array, this will appear to copy the data to a temporary location first.
 220    * An ArrayStoreException in the middle of copying will leave earlier
 221    * elements copied, but later elements unchanged.
 222    *
 223    * @param src the array to copy elements from
 224    * @param srcStart the starting position in src
 225    * @param dest the array to copy elements to
 226    * @param destStart the starting position in dest
 227    * @param len the number of elements to copy
 228    * @throws NullPointerException if src or dest is null
 229    * @throws ArrayStoreException if src or dest is not an array, if they are
 230    *         not compatible array types, or if an incompatible runtime type
 231    *         is stored in dest
 232    * @throws IndexOutOfBoundsException if len is negative, or if the start or
 233    *         end copy position in either array is out of bounds
 234    */
 235   public static native void arraycopy(Object src, int srcStart,
 236                                       Object dest, int destStart, int len);
 237
 238   /**
 239    * Get a hash code computed by the VM for the Object. This hash code will
 240    * be the same as Object's hashCode() method.  It is usually some
 241    * convolution of the pointer to the Object internal to the VM.  It
 242    * follows standard hash code rules, in that it will remain the same for a
 243    * given Object for the lifetime of that Object.
 244    *
 245    * @param o the Object to get the hash code for
 246    * @return the VM-dependent hash code for this Object
 247    * @since 1.1
 248    */
 249   public static native int identityHashCode(Object o);
 250
 251   /**
 252    * Get all the system properties at once. A security check may be performed,
 253    * <code>checkPropertiesAccess</code>. Note that a security manager may
 254    * allow getting a single property, but not the entire group.
 255    *
 256    * <p>The required properties include:
 257    * <dl>
 258    * <dt>java.version</dt>         <dd>Java version number</dd>
 259    * <dt>java.vendor</dt>          <dd>Java vendor specific string</dd>
 260    * <dt>java.vendor.url</dt>      <dd>Java vendor URL</dd>
 261    * <dt>java.home</dt>            <dd>Java installation directory</dd>
 262    * <dt>java.vm.specification.version</dt> <dd>VM Spec version</dd>
 263    * <dt>java.vm.specification.vendor</dt>  <dd>VM Spec vendor</dd>
 264    * <dt>java.vm.specification.name</dt>    <dd>VM Spec name</dd>
 265    * <dt>java.vm.version</dt>      <dd>VM implementation version</dd>
 266    * <dt>java.vm.vendor</dt>       <dd>VM implementation vendor</dd>
 267    * <dt>java.vm.name</dt>         <dd>VM implementation name</dd>
 268    * <dt>java.specification.version</dt>    <dd>Java Runtime Environment version</dd>
 269    * <dt>java.specification.vendor</dt>     <dd>Java Runtime Environment vendor</dd>
 270    * <dt>java.specification.name</dt>       <dd>Java Runtime Environment name</dd>
 271    * <dt>java.class.version</dt>   <dd>Java class version number</dd>
 272    * <dt>java.class.path</dt>      <dd>Java classpath</dd>
 273    * <dt>java.library.path</dt>    <dd>Path for finding Java libraries</dd>
 274    * <dt>java.io.tmpdir</dt>       <dd>Default temp file path</dd>
 275    * <dt>java.compiler</dt>        <dd>Name of JIT to use</dd>
 276    * <dt>java.ext.dirs</dt>        <dd>Java extension path</dd>
 277    * <dt>os.name</dt>              <dd>Operating System Name</dd>
 278    * <dt>os.arch</dt>              <dd>Operating System Architecture</dd>
 279    * <dt>os.version</dt>           <dd>Operating System Version</dd>
 280    * <dt>file.separator</dt>       <dd>File separator ("/" on Unix)</dd>
 281    * <dt>path.separator</dt>       <dd>Path separator (":" on Unix)</dd>
 282    * <dt>line.separator</dt>       <dd>Line separator ("\n" on Unix)</dd>
 283    * <dt>user.name</dt>            <dd>User account name</dd>
 284    * <dt>user.home</dt>            <dd>User home directory</dd>
 285    * <dt>user.dir</dt>             <dd>User's current working directory</dd>
 286    * </dl>
 287    *
 288    * In addition, gnu defines several other properties, where ? stands for
 289    * each character in '0' through '9':
 290    * <dl>
 291    * <dt>gnu.classpath.home</dt>         <dd>Path to the classpath libraries.</dd>
 292    * <dt>gnu.classpath.version</dt>      <dd>Version of the classpath libraries.</dd>
 293    * <dt>gnu.classpath.vm.shortname</dt> <dd>Succinct version of the VM name;
 294    *     used for finding property files in file system</dd>
 295    * <dt>gnu.classpath.home.url</dt>     <dd> Base URL; used for finding
 296    *     property files in file system</dd>
 297    * <dt>gnu.cpu.endian</dt>             <dd>big or little</dd>
 298    * <dt>gnu.java.io.encoding_scheme_alias.ISO-8859-?</dt>   <dd>8859_?</dd>
 299    * <dt>gnu.java.io.encoding_scheme_alias.iso-8859-?</dt>   <dd>8859_?</dd>
 300    * <dt>gnu.java.io.encoding_scheme_alias.iso8859_?</dt>    <dd>8859_?</dd>
 301    * <dt>gnu.java.io.encoding_scheme_alias.iso-latin-_?</dt> <dd>8859_?</dd>
 302    * <dt>gnu.java.io.encoding_scheme_alias.latin?</dt>       <dd>8859_?</dd>
 303    * <dt>gnu.java.io.encoding_scheme_alias.UTF-8</dt>        <dd>UTF8</dd>
 304    * <dt>gnu.java.io.encoding_scheme_alias.utf-8</dt>        <dd>UTF8</dd>
 305    * </dl>
 306    *
 307    * @return the system properties, will never be null
 308    * @throws SecurityException if permission is denied
 309    */
 310   public static Properties getProperties()
 311   {
 312     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 313     if (sm != null)
 314       sm.checkPropertiesAccess();
 315     return SystemProperties.getProperties();
 316   }
 317
 318   /**
 319    * Set all the system properties at once. A security check may be performed,
 320    * <code>checkPropertiesAccess</code>. Note that a security manager may
 321    * allow setting a single property, but not the entire group. An argument
 322    * of null resets the properties to the startup default.
 323    *
 324    * @param properties the new set of system properties
 325    * @throws SecurityException if permission is denied
 326    */
 327   public static void setProperties(Properties properties)
 328   {
 329     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 330     if (sm != null)
 331       sm.checkPropertiesAccess();
 332     SystemProperties.setProperties(properties);
 333   }
 334
 335   /**
 336    * Get a single system property by name. A security check may be performed,
 337    * <code>checkPropertyAccess(key)</code>.
 338    *
 339    * @param key the name of the system property to get
 340    * @return the property, or null if not found
 341    * @throws SecurityException if permission is denied
 342    * @throws NullPointerException if key is null
 343    * @throws IllegalArgumentException if key is ""
 344    */
 345   public static String getProperty(String key)
 346   {
 347     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 348     if (sm != null)
 349       sm.checkPropertyAccess(key);
 350     else if (key.length() == 0)
 351       throw new IllegalArgumentException("key can't be empty");
 352     return SystemProperties.getProperty(key);
 353   }
 354
 355   /**
 356    * Get a single system property by name. A security check may be performed,
 357    * <code>checkPropertyAccess(key)</code>.
 358    *
 359    * @param key the name of the system property to get
 360    * @param def the default
 361    * @return the property, or def if not found
 362    * @throws SecurityException if permission is denied
 363    * @throws NullPointerException if key is null
 364    * @throws IllegalArgumentException if key is ""
 365    */
 366   public static String getProperty(String key, String def)
 367   {
 368     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 369     if (sm != null)
 370       sm.checkPropertyAccess(key);
 371     return SystemProperties.getProperty(key, def);
 372   }
 373
 374   /**
 375    * Set a single system property by name. A security check may be performed,
 376    * <code>checkPropertyAccess(key, "write")</code>.
 377    *
 378    * @param key the name of the system property to set
 379    * @param value the new value
 380    * @return the previous value, or null
 381    * @throws SecurityException if permission is denied
 382    * @throws NullPointerException if key is null
 383    * @throws IllegalArgumentException if key is ""
 384    * @since 1.2
 385    */
 386   public static String setProperty(String key, String value)
 387   {
 388     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 389     if (sm != null)
 390       sm.checkPermission(new PropertyPermission(key, "write"));
 391     return SystemProperties.setProperty(key, value);
 392   }
 393
 394   /**
 395    * Gets the value of an environment variable.
 396    *
 397    * @param name the name of the environment variable
 398    * @return the string value of the variable or null when the
 399    *         environment variable is not defined.
 400    * @throws NullPointerException
 401    * @throws SecurityException if permission is denied
 402    * @since 1.5
 403    * @specnote This method was deprecated in some JDK releases, but
 404    *           was restored in 1.5.
 405    */
 406   public static String getenv(String name)
 407   {
 408     if (name == null)
 409       throw new NullPointerException();
 410     SecurityManager sm = Runtime.securityManager; // Be thread-safe.
 411     if (sm != null)
 412       sm.checkPermission(new RuntimePermission("getenv." + name));
 413     return getenv0(name);
 414   }
 415
 416   /**
 417    * Terminate the Virtual Machine. This just calls
 418    * <code>Runtime.getRuntime().exit(status)</code>, and never returns.
 419    * Obviously, a security check is in order, <code>checkExit</code>.
 420    *
 421    * @param status the exit status; by convention non-zero is abnormal
 422    * @throws SecurityException if permission is denied
 423    * @see Runtime#exit(int)
 424    */
 425   public static void exit(int status)
 426   {
 427     Runtime.getRuntime().exit(status);
 428   }
 429
 430   /**
 431    * Calls the garbage collector. This is only a hint, and it is up to the
 432    * implementation what this hint suggests, but it usually causes a
 433    * best-effort attempt to reclaim unused memory from discarded objects.
 434    * This calls <code>Runtime.getRuntime().gc()</code>.
 435    *
 436    * @see Runtime#gc()
 437    */
 438   public static void gc()
 439   {
 440     Runtime.getRuntime().gc();
 441   }
 442
 443   /**
 444    * Runs object finalization on pending objects. This is only a hint, and
 445    * it is up to the implementation what this hint suggests, but it usually
 446    * causes a best-effort attempt to run finalizers on all objects ready
 447    * to be reclaimed. This calls
 448    * <code>Runtime.getRuntime().runFinalization()</code>.
 449    *
 450    * @see Runtime#runFinalization()
 451    */
 452   public static void runFinalization()
 453   {
 454     Runtime.getRuntime().runFinalization();
 455   }
 456
 457   /**
 458    * Tell the Runtime whether to run finalization before exiting the
 459    * JVM.  This is inherently unsafe in multi-threaded applications,
 460    * since it can force initialization on objects which are still in use
 461    * by live threads, leading to deadlock; therefore this is disabled by
 462    * default. There may be a security check, <code>checkExit(0)</code>. This
 463    * calls <code>Runtime.getRuntime().runFinalizersOnExit()</code>.
 464    *
 465    * @param finalizeOnExit whether to run finalizers on exit
 466    * @throws SecurityException if permission is denied
 467    * @see Runtime#runFinalizersOnExit()
 468    * @since 1.1
 469    * @deprecated never rely on finalizers to do a clean, thread-safe,
 470    *             mop-up from your code
 471    */
 472   public static void runFinalizersOnExit(boolean finalizeOnExit)
 473   {
 474     Runtime.getRuntime().runFinalizersOnExit(finalizeOnExit);
 475   }
 476
 477   /**
 478    * Load a code file using its explicit system-dependent filename. A security
 479    * check may be performed, <code>checkLink</code>. This just calls
 480    * <code>Runtime.getRuntime().load(filename)</code>.
 481    *
 482    * <p>
 483    * The library is loaded using the class loader associated with the
 484    * class associated with the invoking method.
 485    *
 486    * @param filename the code file to load
 487    * @throws SecurityException if permission is denied
 488    * @throws UnsatisfiedLinkError if the file cannot be loaded
 489    * @see Runtime#load(String)
 490    */
 491   public static void load(String filename)
 492   {
 493     Runtime.getRuntime().load(filename);
 494   }
 495
 496   /**
 497    * Load a library using its explicit system-dependent filename. A security
 498    * check may be performed, <code>checkLink</code>. This just calls
 499    * <code>Runtime.getRuntime().load(filename)</code>.
 500    *
 501    * <p>
 502    * The library is loaded using the class loader associated with the
 503    * class associated with the invoking method.
 504    *
 505    * @param libname the library file to load
 506    * @throws SecurityException if permission is denied
 507    * @throws UnsatisfiedLinkError if the file cannot be loaded
 508    * @see Runtime#load(String)
 509    */
 510   public static void loadLibrary(String libname)
 511   {
 512     Runtime.getRuntime().loadLibrary(libname);
 513   }
 514
 515   /**
 516    * Convert a library name to its platform-specific variant.
 517    *
 518    * @param libname the library name, as used in <code>loadLibrary</code>
 519    * @return the platform-specific mangling of the name
 520    * @since 1.2
 521    */
 522   public static String mapLibraryName(String libname)
 523   {
 524     // XXX Fix this!!!!
 525     return Runtime.nativeGetLibname("", libname);
 526   }
 527
 528   /**
 529    * Set {@link #in} to a new InputStream.
 530    *
 531    * @param in the new InputStream
 532    * @see #setIn(InputStream)
 533    */
 534   private static native void setIn0(InputStream in);
 535
 536   /**
 537    * Set {@link #out} to a new PrintStream.
 538    *
 539    * @param out the new PrintStream
 540    * @see #setOut(PrintStream)
 541    */
 542   private static native void setOut0(PrintStream out);
 543
 544   /**
 545    * Set {@link #err} to a new PrintStream.
 546    *
 547    * @param err the new PrintStream
 548    * @see #setErr(PrintStream)
 549    */
 550   private static native void setErr0(PrintStream err);
 551
 552   /**
 553    * Gets the value of an environment variable.
 554    *
 555    * @see #getenv(String)
 556    */
 557   static native String getenv0(String name);
 558 } // class System