public  void destroy() 
{
 terminateProcess(handle);
}

 public int exitValue() 
{
        
        int exitCode = getExitCodeProcess(handle);
        if (exitCode == STILL_ACTIVE)
            throw new IllegalThreadStateException("process has not exited");
        return exitCode;
}

 public  void finalize() 
{
        closeHandle(handle);
}

 public InputStream getErrorStream() 
{
        return stderr_stream;
}

 public InputStream getInputStream() 
{
        return stdout_stream;
}

 public OutputStream getOutputStream() 
{
        return stdin_stream;
}

 static Process start(String[] cmdarray,
    Map environment,
    String dir,
    Redirect[] redirects,
    boolean redirectErrorStream) throws IOException 
{
    // System-dependent portion of ProcessBuilder.start()
        String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
        FileInputStream  f0 = null;
        FileOutputStream f1 = null;
        FileOutputStream f2 = null;
        try {
            long[] stdHandles;
            if (redirects == null) {
                stdHandles = new long[] { -1L, -1L, -1L };
            } else {
                stdHandles = new long[3];
                if (redirects[0] == Redirect.PIPE)
                    stdHandles[0] = -1L;
                else if (redirects[0] == Redirect.INHERIT)
                    stdHandles[0] = fdAccess.getHandle(FileDescriptor.in);
                else {
                    f0 = new FileInputStream(redirects[0].file());
                    stdHandles[0] = fdAccess.getHandle(f0.getFD());
                }
                if (redirects[1] == Redirect.PIPE)
                    stdHandles[1] = -1L;
                else if (redirects[1] == Redirect.INHERIT)
                    stdHandles[1] = fdAccess.getHandle(FileDescriptor.out);
                else {
                    f1 = redirects[1].toFileOutputStream();
                    stdHandles[1] = fdAccess.getHandle(f1.getFD());
                }
                if (redirects[2] == Redirect.PIPE)
                    stdHandles[2] = -1L;
                else if (redirects[2] == Redirect.INHERIT)
                    stdHandles[2] = fdAccess.getHandle(FileDescriptor.err);
                else {
                    f2 = redirects[2].toFileOutputStream();
                    stdHandles[2] = fdAccess.getHandle(f2.getFD());
                }
            }
            return new ProcessImpl(cmdarray, envblock, dir,
                                   stdHandles, redirectErrorStream);
        } finally {
            // In theory, close() can throw IOException
            // (although it is rather unlikely to happen here)
            try { if (f0 != null) f0.close(); }
            finally {
                try { if (f1 != null) f1.close(); }
                finally { if (f2 != null) f2.close(); }
            }
        }
}

 public int waitFor() throws InterruptedException 
{
        waitForInterruptibly(handle);
        if (Thread.interrupted())
            throw new InterruptedException();
        return exitValue();
}