home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / Chip_1997-10_cd.bin / tema / sybase / powerj / java.z / System.java < prev    next >
Text File  |  1996-05-03  |  9KB  |  270 lines
  1. /*
  2.  * @(#)System.java    1.55 95/11/13 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.lang;
  21.  
  22. import java.io.*;
  23. import java.util.Properties;
  24. import java.util.StringTokenizer;
  25.  
  26. /**
  27.  * This Class provides a system-independent interface to system 
  28.  * functionality.  One of the more useful things provided by this Class
  29.  * are the standard input and output streams. The standard input streams are
  30.  * used for reading character data.  The standard output streams are used for
  31.  * printing. For example:
  32.  * <pre>
  33.  *    System.out.println("Hello World!");
  34.  * </pre>
  35.  * This Class cannot be instantiated or subclassed because all of the methods
  36.  * and variables are static.
  37.  * @version     1.55, 13 Nov 1995
  38.  * @author    Arthur van Hoff
  39.  */
  40. public final
  41. class System {
  42.  
  43.     /** Don't let anyone instantiate this class */
  44.     private System() {
  45.     }
  46.  
  47.     /**
  48.      * Standard input stream.  This stream is used for reading in character
  49.      * data.
  50.      */
  51.     public static InputStream in;
  52.  
  53.     /**
  54.      * Standard output stream. This stream is used for printing messages.
  55.      */
  56.     public static PrintStream out;
  57.  
  58.     /**
  59.      * Standard error stream. This stream can be used to print error messages.
  60.      * Many applications read in data from an InputStream and output messages via
  61.      * the PrintStream out statement.  Often applications rely on command line
  62.      * redirection to specify source and destination files.  A problem with redirecting
  63.      * standard output is the incapability of writing messages to the screen if the
  64.      * output has been redirected to a file.  This problem can be overcome by sending
  65.      * some output to PrintStream out and other output to PrintStream err.  The
  66.      * difference between PrintStream err and PrintStream out is that PrintStream
  67.      * err is often used for displaying error messages but may be used for any purpose.
  68.      */
  69.     public static PrintStream err;
  70.  
  71.     static {
  72.     try {
  73.         in = new BufferedInputStream(new FileInputStream(FileDescriptor.in), 128);
  74.         out = new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out), 128), true);
  75.         err = new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err), 128), true);
  76.     } catch (Exception e) {
  77.         throw new Error("can't initialize stdio");
  78.     }
  79.     }
  80.  
  81.     /* The security manager for the system.
  82.      */
  83.     private static SecurityManager security;
  84.  
  85.     /**
  86.      * Sets the System security. This value can only be set once.
  87.      * @param s the security manager
  88.      * @exception SecurityException If the SecurityManager has already been set.
  89.      */
  90.     public static void setSecurityManager(SecurityManager s) {
  91.     if (security != null) {
  92.         throw new SecurityException("SecurityManager already set");
  93.     }
  94.     security = s;
  95.     }
  96.  
  97.     /**
  98.      * Gets the system security interface.
  99.      */
  100.     public static SecurityManager getSecurityManager() {
  101.     return security;
  102.     }
  103.  
  104.     /**
  105.      * Returns the current time in milliseconds GMT since the epoch (00:00:00
  106.      * UTC, January 1, 1970).  It is a signed 64 bit integer, and so it will
  107.      * not overflow until the year 292280995.
  108.      * @see java.util.Date
  109.      */
  110.     public static native long currentTimeMillis();
  111.  
  112.  
  113.     /** 
  114.      * Copies an array from the source array, beginning at the
  115.      * specified position, to the specified position of the destination array.
  116.      * This method does not allocate memory for the destination array.  The
  117.      * memory must already be allocated.
  118.      * @param src    the source data
  119.      * @param srcpos    start position in the source data
  120.      * @param dest    the destination
  121.      * @param destpos    start position in the destination data
  122.      * @param length    the number of array elements to be copied
  123.      * @exception ArrayIndexOutOfBoundsException If copy would cause
  124.      *            access of data outside array bounds.
  125.      * @exception ArrayStoreException If an element in the src array could
  126.      *          could not be stored into the destination array due
  127.      *            to a type mismatch
  128.      */
  129.     public static native void arraycopy(Object src, int src_position,
  130.                                         Object dst, int dst_position,
  131.                                         int length);
  132.  
  133.     /**
  134.      * System properties. The following properties are guaranteed to be defined:
  135.      * <dl>
  136.      * <dt>java.version        <dd>Java version number
  137.      * <dt>java.vendor        <dd>Java vendor specific string
  138.      * <dt>java.vendor.url    <dd>Java vendor URL
  139.      * <dt>java.home        <dd>Java installation directory
  140.      * <dt>java.class.version    <dd>Java class version number
  141.      * <dt>java.class.path    <dd>Java classpath
  142.      * <dt>os.name        <dd>Operating System Name
  143.      * <dt>os.arch        <dd>Operating System Architecture
  144.      * <dt>os.version        <dd>Operating System Version
  145.      * <dt>file.separator    <dd>File separator ("/" on Unix)
  146.      * <dt>path.separator    <dd>Path separator (":" on Unix)
  147.      * <dt>line.separator    <dd>Line separator ("\n" on Unix)
  148.      * <dt>user.name        <dd>User account name
  149.      * <dt>user.home        <dd>User home directory
  150.      * <dt>user.dir        <dd>User's current working directory
  151.      * </dl>
  152.      */
  153.     private static Properties props;
  154.     private static native Properties initProperties(Properties props);
  155.  
  156.     /**
  157.      * Gets the System properties.
  158.      */
  159.     public static Properties getProperties() {
  160.     if (props == null) {
  161.         props = initProperties(new Properties());
  162.     }
  163.     if (security != null) {
  164.         security.checkPropertiesAccess();
  165.     }
  166.     return props;
  167.     }
  168.  
  169.     /**
  170.      * Sets the System properties to the specified properties.
  171.      * @param props the properties to be set
  172.      */
  173.     public static void setProperties(Properties props) {
  174.     if (security != null) {
  175.         security.checkPropertiesAccess();
  176.     }
  177.     System.props = props;
  178.     }
  179.     
  180.     /**
  181.      * Gets the System property indicated by the specified key.
  182.      * @param key the name of the system property
  183.      */
  184.     public static String getProperty(String key) {
  185.     if (security != null) {
  186.         security.checkPropertyAccess(key);
  187.     }
  188.     if (props == null) {
  189.         props = initProperties(new Properties());
  190.     }
  191.     return props.getProperty(key);
  192.     }
  193.     
  194.     /**
  195.      * Gets the System property indicated by the specified key and def.
  196.      * @param key the name of the system property
  197.      * @param def the default value to use if this property is not set
  198.      */
  199.     public static String getProperty(String key, String def) {
  200.     if (security != null) {
  201.         security.checkPropertyAccess(key); 
  202.     }
  203.     if (props == null) {
  204.         props = initProperties(new Properties());
  205.     }
  206.     return props.getProperty(key, def);
  207.     }
  208.     
  209.     /** Obsolete. 
  210.      * Gets an environment variable. An environment variable is a
  211.      * system dependent external variable that has a string value.
  212.      * @param name the name of the environment variable
  213.      * @return     the value of the variable, or null if the variable is
  214.      *        not defined.
  215.      * 
  216.      */
  217.     public static String getenv(String name) {
  218.     throw new Error("getenv no longer supported, use properties and -D instead: " + name);
  219.     }
  220.  
  221.  
  222.     /**
  223.      * Exits the virtual machine with an exit code. This method does
  224.      * not return, use with caution.
  225.      * @param status exit status, 0 if successful, other values indicate
  226.      *        various error types. 
  227.      * @see Runtime#exit
  228.      */
  229.     public static void exit (int status) {
  230.     Runtime.getRuntime().exit(status);
  231.     }
  232.  
  233.     /**
  234.      * Runs the garbage collector.
  235.      * @see Runtime#gc
  236.      */
  237.     public static void gc() {
  238.     Runtime.getRuntime().gc();
  239.     }
  240.  
  241.     /**
  242.      * Runs the finalization methods of any objects pending finalization.
  243.      * @see Runtime#gc
  244.      */
  245.     public static void runFinalization() {
  246.     Runtime.getRuntime().runFinalization();
  247.     }
  248.  
  249.     /**
  250.      * Loads a dynamic library, given a complete path name. 
  251.      * @param filename the file to load
  252.      * @exception UnsatisfiedLinkError If the file does not exist.
  253.      * @see Runtime#load
  254.      */
  255.     public static void load(String filename) {
  256.     Runtime.getRuntime().load(filename);
  257.     }
  258.  
  259.     /**
  260.      * Loads a dynamic library with the specified library name. 
  261.      * @param libname the name of the library
  262.      * @exception UnsatisfiedLinkError If the library does not exist. 
  263.      * @see Runtime#loadLibrary
  264.      */
  265.     public static void loadLibrary(String libname) {
  266.     Runtime.getRuntime().loadLibrary(libname);
  267.     }
  268.  
  269. }
  270.