if (out != null) {                            // Read process output on this thread                            if (err != null) {                                errThread = new PipeThread(true, errProcess,                                                           err);                                errThread.start();                            }                            if (in != null) {                                inThread = new PipeThread(false, in,                                                          inProcess);                                inThread.start();                            }                            pipe(true, outProcess, out);                        } else if (in != null) {                            // No output, read process input on this thread                            if (err != null) {                                errThread = new PipeThread(true, errProcess,                                                           err);                                errThread.start();                            }                            pipe(false, in, inProcess);                            in.close();                        } else if (err != null) {                            // No output or input, read process err                            // on this thread                            pipe(true, errProcess, err);                            errProcess.close();                            errProcess = null;                        }                        // wait for process completion                        for (;;) {                            try { p.waitFor(); break; }                            catch (InterruptedException ex) { }                        }                        return p.exitValue();                    } finally {                        // pipe will close stream as well, but for reliability                        // duplicate it in any case                        if (inProcess != null) {                            inProcess.close();                        }                    }                } finally {                    if (outProcess != null) {                        outProcess.close();                    }                }            } finally {                if (errProcess != null) {                    errProcess.close();                }            }        } finally {            p.destroy();            if (inThread != null) {                for (;;) {                    try { inThread.join(); break; }                    catch (InterruptedException ex) { }                }            }            if (errThread != null) {                for (;;) {                    try { errThread.join(); break; }                    catch (InterruptedException ex) { }                }            }        }    }    static void pipe(boolean fromProcess, InputStream from, OutputStream to)        throws IOException    {        try {            final int SIZE = 4096;            byte[] buffer = new byte[SIZE];            for (;;) {                int n;                if (!fromProcess) {                    n = from.read(buffer, 0, SIZE);                } else {                    try {                        n = from.read(buffer, 0, SIZE);                    } catch (IOException ex) {                        // Ignore exception as it can be cause by closed pipe                        break;                    }                }                if (n < 0) { break; }                if (fromProcess) {                    to.write(buffer, 0, n);                    to.flush();                } else {                    try {                        to.write(buffer, 0, n);                        to.flush();                    } catch (IOException ex) {                        // Ignore exception as it can be cause by closed pipe                        break;                    }                }            }        } finally {            try {                if (fromProcess) {                    from.close();                } else {                    to.close();                }            } catch (IOException ex) {                // Ignore errors on close. On Windows JVM may throw invalid                // refrence exception if process terminates too fast.            }        }    }    private static InputStream toInputStream(Object value)        throws IOException    {        InputStream is = null;        String s = null;        if (value instanceof Wrapper) {            Object unwrapped = ((Wrapper)value).unwrap();            if (unwrapped instanceof InputStream) {                is = (InputStream)unwrapped;            } else if (unwrapped instanceof byte[]) {                is = new ByteArrayInputStream((byte[])unwrapped);            } else if (unwrapped instanceof Reader) {                s = readReader((Reader)unwrapped);            } else if (unwrapped instanceof char[]) {                s = new String((char[])unwrapped);            }        }        if (is == null) {            if (s == null) { s = ScriptRuntime.toString(value); }            is = new ByteArrayInputStream(s.getBytes());        }        return is;    }    private static OutputStream toOutputStream(Object value) {        OutputStream os = null;        if (value instanceof Wrapper) {            Object unwrapped = ((Wrapper)value).unwrap();            if (unwrapped instanceof OutputStream) {                os = (OutputStream)unwrapped;            }        }        return os;    }    private static String readUrl(String filePath, String charCoding,                                  boolean urlIsFile)        throws IOException    {        int chunkLength;        InputStream is = null;        try {            if (!urlIsFile) {                URL urlObj = new URL(filePath);                URLConnection uc = urlObj.openConnection();                is = uc.getInputStream();                chunkLength = uc.getContentLength();                if (chunkLength <= 0)                    chunkLength = 1024;                if (charCoding == null) {                    String type = uc.getContentType();                    if (type != null) {                        charCoding = getCharCodingFromType(type);                    }                }            } else {                File f = new File(filePath);                long length = f.length();                chunkLength = (int)length;                if (chunkLength != length)                    throw new IOException("Too big file size: "+length);                if (chunkLength == 0) { return ""; }                is = new FileInputStream(f);            }            Reader r;            if (charCoding == null) {                r = new InputStreamReader(is);            } else {                r = new InputStreamReader(is, charCoding);            }            return readReader(r, chunkLength);        } finally {            if (is != null)                is.close();        }    }    private static String getCharCodingFromType(String type)    {        int i = type.indexOf(';');        if (i >= 0) {            int end = type.length();            ++i;            while (i != end && type.charAt(i) <= ' ') {                ++i;            }            String charset = "charset";            if (charset.regionMatches(true, 0, type, i, charset.length()))            {                i += charset.length();                while (i != end && type.charAt(i) <= ' ') {                    ++i;                }                if (i != end && type.charAt(i) == '=') {                    ++i;                    while (i != end && type.charAt(i) <= ' ') {                        ++i;                    }                    if (i != end) {                        // i is at the start of non-empty                        // charCoding spec                        while (type.charAt(end -1) <= ' ') {                            --end;                        }                        return type.substring(i, end);                    }                }            }        }        return null;    }    private static String readReader(Reader reader)        throws IOException    {        return readReader(reader, 4096);    }    private static String readReader(Reader reader, int initialBufferSize)        throws IOException    {        char[] buffer = new char[initialBufferSize];        int offset = 0;        for (;;) {            int n = reader.read(buffer, offset, buffer.length - offset);            if (n < 0) { break;    }            offset += n;            if (offset == buffer.length) {                char[] tmp = new char[buffer.length * 2];                System.arraycopy(buffer, 0, tmp, 0, offset);                buffer = tmp;            }        }        return new String(buffer, 0, offset);    }    static RuntimeException reportRuntimeError(String msgId) {        String message = ToolErrorReporter.getMessage(msgId);        return Context.reportRuntimeError(message);    }    static RuntimeException reportRuntimeError(String msgId, String msgArg)    {        String message = ToolErrorReporter.getMessage(msgId, msgArg);        return Context.reportRuntimeError(message);    }    NativeArray history;    private InputStream inStream;    private PrintStream outStream;    private PrintStream errStream;    private boolean sealedStdLib = false;    boolean initialized;}class Runner implements Runnable, ContextAction {    Runner(Scriptable scope, Function func, Object[] args) {        this.scope = scope;        f = func;        this.args = args;    }    Runner(Scriptable scope, Script script) {        this.scope = scope;        s = script;    }    public void run()    {        factory.call(this);    }    public Object run(Context cx)    {        if (f != null)            return f.call(cx, scope, scope, args);        else            return s.exec(cx, scope);    }    ContextFactory factory;    private Scriptable scope;    private Function f;    private Script s;    private Object[] args;}class PipeThread extends Thread {    PipeThread(boolean fromProcess, InputStream from, OutputStream to) {        setDaemon(true);        this.fromProcess = fromProcess;        this.from = from;        this.to = to;    }    public void run() {        try {            Global.pipe(fromProcess, from, to);        } catch (IOException ex) {            throw Context.throwAsScriptRuntimeEx(ex);        }    }    private boolean fromProcess;    private InputStream from;    private OutputStream to;}