* new function synchronizes on the <code>this</code> object of     * its invocation.     * js> var o = { f : sync(function(x) {     *       print("entry");     *       Packages.java.lang.Thread.sleep(x*1000);     *       print("exit");     *     })};     * js> spawn(function() {o.f(5);});     * Thread[Thread-0,5,main]     * entry     * js> spawn(function() {o.f(5);});     * Thread[Thread-1,5,main]     * js>     * exit     * entry     * exit     */    public static Object sync(Context cx, Scriptable thisObj, Object[] args,                              Function funObj)    {        if (args.length == 1 && args[0] instanceof Function) {            return new Synchronizer((Function)args[0]);        }        else {            throw reportRuntimeError("msg.sync.args");        }    }    /**     * Execute the specified command with the given argument and options     * as a separate process and return the exit status of the process.     * <p>     * Usage:     * <pre>     * runCommand(command)     * runCommand(command, arg1, ..., argN)     * runCommand(command, arg1, ..., argN, options)     * </pre>     * All except the last arguments to runCommand are converted to strings     * and denote command name and its arguments. If the last argument is a     * JavaScript object, it is an option object. Otherwise it is converted to     * string denoting the last argument and options objects assumed to be     * empty.     * Te following properties of the option object are processed:     * <ul>     * <li><tt>args</tt> - provides an array of additional command arguments     * <li><tt>env</tt> - explicit environment object. All its enumeratable     *   properties define the corresponding environment variable names.     * <li><tt>input</tt> - the process input. If it is not     *   java.io.InputStream, it is converted to string and sent to the process     *   as its input. If not specified, no input is provided to the process.     * <li><tt>output</tt> - the process output instead of     *   java.lang.System.out. If it is not instance of java.io.OutputStream,     *   the process output is read, converted to a string, appended to the     *   output property value converted to string and put as the new value of     *   the output property.     * <li><tt>err</tt> - the process error output instead of     *   java.lang.System.err. If it is not instance of java.io.OutputStream,     *   the process error output is read, converted to a string, appended to     *   the err property value converted to string and put as the new     *   value of the err property.     * </ul>     */    public static Object runCommand(Context cx, Scriptable thisObj,                                    Object[] args, Function funObj)        throws IOException    {        int L = args.length;        if (L == 0 || (L == 1 && args[0] instanceof Scriptable)) {            throw reportRuntimeError("msg.runCommand.bad.args");        }        InputStream in = null;        OutputStream out = null, err = null;        ByteArrayOutputStream outBytes = null, errBytes = null;        Object outObj = null, errObj = null;        String[] environment = null;        Scriptable params = null;        Object[] addArgs = null;        if (args[L - 1] instanceof Scriptable) {            params = (Scriptable)args[L - 1];            --L;            Object envObj = ScriptableObject.getProperty(params, "env");            if (envObj != Scriptable.NOT_FOUND) {                if (envObj == null) {                    environment = new String[0];                } else {                    if (!(envObj instanceof Scriptable)) {                        throw reportRuntimeError("msg.runCommand.bad.env");                    }                    Scriptable envHash = (Scriptable)envObj;                    Object[] ids = ScriptableObject.getPropertyIds(envHash);                    environment = new String[ids.length];                    for (int i = 0; i != ids.length; ++i) {                        Object keyObj = ids[i], val;                        String key;                        if (keyObj instanceof String) {                            key = (String)keyObj;                            val = ScriptableObject.getProperty(envHash, key);                        } else {                            int ikey = ((Number)keyObj).intValue();                            key = Integer.toString(ikey);                            val = ScriptableObject.getProperty(envHash, ikey);                        }                        if (val == ScriptableObject.NOT_FOUND) {                            val = Undefined.instance;                        }                        environment[i] = key+'='+ScriptRuntime.toString(val);                    }                }            }            Object inObj = ScriptableObject.getProperty(params, "input");            if (inObj != Scriptable.NOT_FOUND) {                in = toInputStream(inObj);            }            outObj = ScriptableObject.getProperty(params, "output");            if (outObj != Scriptable.NOT_FOUND) {                out = toOutputStream(outObj);                if (out == null) {                    outBytes = new ByteArrayOutputStream();                    out = outBytes;                }            }            errObj = ScriptableObject.getProperty(params, "err");            if (errObj != Scriptable.NOT_FOUND) {                err = toOutputStream(errObj);                if (err == null) {                    errBytes = new ByteArrayOutputStream();                    err = errBytes;                }            }            Object addArgsObj = ScriptableObject.getProperty(params, "args");            if (addArgsObj != Scriptable.NOT_FOUND) {                Scriptable s = Context.toObject(addArgsObj,                                                getTopLevelScope(thisObj));                addArgs = cx.getElements(s);            }        }        Global global = getInstance(funObj);        if (out == null) {            out = (global != null) ? global.getOut() : System.out;        }        if (err == null) {            err = (global != null) ? global.getErr() : System.err;        }        // If no explicit input stream, do not send any input to process,        // in particular, do not use System.in to avoid deadlocks        // when waiting for user input to send to process which is already        // terminated as it is not always possible to interrupt read method.        String[] cmd = new String[(addArgs == null) ? L : L + addArgs.length];        for (int i = 0; i != L; ++i) {            cmd[i] = ScriptRuntime.toString(args[i]);        }        if (addArgs != null) {            for (int i = 0; i != addArgs.length; ++i) {                cmd[L + i] = ScriptRuntime.toString(addArgs[i]);            }        }        int exitCode = runProcess(cmd, environment, in, out, err);        if (outBytes != null) {            String s = ScriptRuntime.toString(outObj) + outBytes.toString();            ScriptableObject.putProperty(params, "output", s);        }        if (errBytes != null) {            String s = ScriptRuntime.toString(errObj) + errBytes.toString();            ScriptableObject.putProperty(params, "err", s);        }        return new Integer(exitCode);    }    /**     * The seal function seals all supplied arguments.     */    public static void seal(Context cx, Scriptable thisObj, Object[] args,                            Function funObj)    {        for (int i = 0; i != args.length; ++i) {            Object arg = args[i];            if (!(arg instanceof ScriptableObject) || arg == Undefined.instance)            {                if (!(arg instanceof Scriptable) || arg == Undefined.instance)                {                    throw reportRuntimeError("msg.shell.seal.not.object");                } else {                    throw reportRuntimeError("msg.shell.seal.not.scriptable");                }            }        }        for (int i = 0; i != args.length; ++i) {            Object arg = args[i];            ((ScriptableObject)arg).sealObject();        }    }    /**     * The readFile reads the given file context and convert it to a string     * using the specified character coding or default character coding if     * explicit coding argument is not given.     * <p>     * Usage:     * <pre>     * readFile(filePath)     * readFile(filePath, charCoding)     * </pre>     * The first form converts file's context to string using the default     * character coding.     */    public static Object readFile(Context cx, Scriptable thisObj, Object[] args,                                  Function funObj)        throws IOException    {        if (args.length == 0) {            throw reportRuntimeError("msg.shell.readFile.bad.args");        }        String path = ScriptRuntime.toString(args[0]);        String charCoding = null;        if (args.length >= 2) {            charCoding = ScriptRuntime.toString(args[1]);        }        return readUrl(path, charCoding, true);    }    /**     * The readUrl opens connection to the given URL, read all its data     * and converts them to a string     * using the specified character coding or default character coding if     * explicit coding argument is not given.     * <p>     * Usage:     * <pre>     * readUrl(url)     * readUrl(url, charCoding)     * </pre>     * The first form converts file's context to string using the default     * charCoding.     */    public static Object readUrl(Context cx, Scriptable thisObj, Object[] args,                                 Function funObj)        throws IOException    {        if (args.length == 0) {            throw reportRuntimeError("msg.shell.readUrl.bad.args");        }        String url = ScriptRuntime.toString(args[0]);        String charCoding = null;        if (args.length >= 2) {            charCoding = ScriptRuntime.toString(args[1]);        }        return readUrl(url, charCoding, false);    }    public InputStream getIn() {        return inStream == null ? System.in : inStream;    }    public void setIn(InputStream in) {        inStream = in;    }    public PrintStream getOut() {        return outStream == null ? System.out : outStream;    }    public void setOut(PrintStream out) {        outStream = out;    }    public PrintStream getErr() {        return errStream == null ? System.err : errStream;    }    public void setErr(PrintStream err) {        errStream = err;    }    public void setSealedStdLib(boolean value)    {        sealedStdLib = value;    }    private static Global getInstance(Function function)    {        Scriptable scope = function.getParentScope();        if (!(scope instanceof Global))            throw reportRuntimeError("msg.bad.shell.function.scope",                                     String.valueOf(scope));        return (Global)scope;    }    /**     * If any of in, out, err is null, the corresponding process stream will     * be closed immediately, otherwise it will be closed as soon as     * all data will be read from/written to process     */    private static int runProcess(String[] cmd, String[] environment,                                  InputStream in, OutputStream out,                                  OutputStream err)        throws IOException    {        Process p;        if (environment == null) {            p = Runtime.getRuntime().exec(cmd);        } else {            p = Runtime.getRuntime().exec(cmd, environment);        }        PipeThread inThread = null, errThread = null;        try {            InputStream errProcess = null;            try {                if (err != null) {                    errProcess = p.getErrorStream();                } else {                    p.getErrorStream().close();                }                InputStream outProcess = null;                try {                    if (out != null) {                        outProcess = p.getInputStream();                    } else {                        p.getInputStream().close();                    }                    OutputStream inProcess = null;                    try {                        if (in != null) {                            inProcess = p.getOutputStream();                        } else {                            p.getOutputStream().close();                        }