toolchain/gcc/libjava/java/lang/Process.java

   1 /* Process.java - Represent spawned system process
   2    Copyright (C) 1998, 1999, 2001, 2002, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.lang;
  40
  41 import java.io.OutputStream;
  42 import java.io.InputStream;
  43
  44 /**
  45  * An instance of a subclass of <code>Process</code> is created by the
  46  * <code>Runtime.exec</code> methods.  Methods in <code>Process</code>
  47  * provide a means to send input to a process, obtain the output from a
  48  * subprocess, destroy a subprocess, obtain the exit value from a
  49  * subprocess, and wait for a subprocess to complete.
  50  *
  51  * <p>This is dependent on the platform, and some processes (like native
  52  * windowing processes, 16-bit processes in Windows, or shell scripts) may
  53  * be limited in functionality. Because some platforms have limited buffers
  54  * between processes, you may need to provide input and read output to prevent
  55  * the process from blocking, or even deadlocking.
  56  *
  57  * <p>Even if all references to this object disapper, the process continues
  58  * to execute to completion. There are no guarantees that the
  59  * subprocess execute asynchronously or concurrently with the process which
  60  * owns this object.
  61  *
  62  * @author Brian Jones
  63  * @author Tom Tromey <tromey@cygnus.com>
  64  * @see Runtime#exec(String[], String[], File)
  65  * @since 1.0
  66  * @status updated to 1.4
  67  */
  68 public abstract class Process
  69 {
  70   /**
  71    * Empty constructor does nothing.
  72    */
  73   public Process()
  74   {
  75   }
  76
  77   /**
  78    * Obtain the output stream that sends data to the subprocess. This is
  79    * the STDIN of the subprocess. When implementing, you should probably
  80    * use a buffered stream.
  81    *
  82    * @return the output stream that pipes to the process input
  83    */
  84   public abstract OutputStream getOutputStream();
  85
  86   /**
  87    * Obtain the input stream that receives data from the subprocess. This is
  88    * the STDOUT of the subprocess. When implementing, you should probably
  89    * use a buffered stream.
  90    *
  91    * @return the input stream that pipes data from the process output
  92    */
  93   public abstract InputStream getInputStream();
  94
  95   /**
  96    * Obtain the input stream that receives data from the subprocess. This is
  97    * the STDERR of the subprocess. When implementing, you should probably
  98    * use a buffered stream.
  99    *
 100    * @return the input stream that pipes data from the process error output
 101    */
 102   public abstract InputStream getErrorStream();
 103
 104   /**
 105    * The thread calling <code>waitFor</code> will block until the subprocess
 106    * has terminated. If the process has already terminated then the method
 107    * immediately returns with the exit value of the subprocess.
 108    *
 109    * @return the subprocess exit value; 0 conventionally denotes success
 110    * @throws InterruptedException if another thread interrupts the blocked one
 111    */
 112   public abstract int waitFor() throws InterruptedException;
 113
 114   /**
 115    * When a process terminates there is associated with that termination
 116    * an exit value for the process to indicate why it terminated. A return
 117    * of <code>0</code> denotes normal process termination by convention.
 118    *
 119    * @return the exit value of the subprocess
 120    * @throws IllegalThreadStateException if the subprocess has not terminated
 121    */
 122   public abstract int exitValue();
 123
 124   /**
 125    * Kills the subprocess and all of its children forcibly.
 126    */
 127   public abstract void destroy();
 128 } // class Process