ctorMember = methods[i];

                break;

            }

        }

        String[] fileFuncs = {

                                "toString",

                                "getName",

                                "getParent",

                                "isAbsolute",

                ctorMember = methods[i];

                break;

            }

        }

        ScriptableObject.defineProperty(scope, "Image", ctor, ScriptableObject.DONTENUM);

    }

                ctorMember = methods[i];

                break;

            }

        }

        String[] ftpFuncs = {

                "login", "cd", "mkdir", "lcd", "putFile",

                "putString", "getFile", "getString", "logout",

                "binary", "ascii"

                            };

        }

        private void runCompiledModule(Script compiled, Context cx, ModuleImpl mod)

        {

                                                      Utils.findMethod(NativeImpl.class, "require"),

                                                      this);

            // The script code found in src/main/javascript is wrapped with a function by the Rhino compiler

            // (see the pom.xml for the wrapper code). What we actually

        exports.setParentScope(null);

        exports.setPrototype(scope);

        ScriptableObject.defineClass(exports, ParserImpl.class);

                                               exports);

        exports.put("HTTPParser", exports, fn);

        return exports;

    }

        // *not* `exports`, and hasn't been initialized here, so it doesn't have a reference to the runtime.

        // With the varargs form, `thisObj` is the "wrong" scope (not a CryptoImpl), and func.getParentScope()

        // is the new, uninitialized CryptoImpl instance.

        ScriptableObject proto = (ScriptableObject) export.getPrototype();

        ScriptableObject.defineClass(export, HashImpl.class, false, true);

        ScriptableObject.defineClass(export, MacImpl.class, false, true);

        ScriptableObject.defineClass(export, CipherImpl.class);

        ScriptableObject.defineClass(export, DecipherImpl.class);

    try {

      Class[] parameters = new Class[] { String.class };

      Method inMethod = ECMAScriptDataModel.class.getMethod("jsIn",

          parameters);

          newDM.scope);

      newDM.scope.put("In", newDM.scope, inFunc);

    } catch (SecurityException e) {

      System.err.println(e);

    } catch (NoSuchMethodException e) {

      Scriptable globalScope = cx.initStandardObjects(s);

      cx.setOptimizationLevel(-1); // must use interpreter mode

     

     

      cx.putThreadLocal("tl", "bla");

     

      globalScope.put("foo", globalScope, f);//necessary or scriptus.foo won't work either...

      globalScope.put("scriptus", globalScope, s);

            continue;

        }

       

          globalScope.put(m.getMethodName(), globalScope,

                          m.getMethodName(),

                          this.getClass().getMethod(m.getMethodName(), m.getMethodArgs()),

                        globalScope)

          );

    }

   

//    globalScope.put("fork", globalScope, new FunctionObject("fork", this.getClass().getMethod("fork"), globalScope));

//    globalScope.put("kill", globalScope, new FunctionObject("kill", this.getClass().getMethod("kill", String.class), globalScope));

//    globalScope.put("exec", globalScope, new FunctionObject("exec", this.getClass().getMethod("exec", String.class, String.class), globalScope));

//    globalScope.put("listen", globalScope, new FunctionObject("listen", this.getClass().getMethod("listen", NativeObject.class), globalScope));

//    globalScope.put("say", globalScope, new FunctionObject("say", this.getClass().getMethod("say", String.class, NativeObject.class), globalScope));

//    globalScope.put("ask", globalScope, new FunctionObject("ask", this.getClass().getMethod("ask", String.class, NativeObject.class), globalScope));

//    globalScope.put("get", globalScope, new FunctionObject("get", this.getClass().getMethod("get", String.class), globalScope));

//    globalScope.put("sleep", globalScope, new FunctionObject("sleep", this.getClass().getMethod("sleep", Object.class), globalScope));

//    globalScope.put("exit", globalScope, new FunctionObject("exit", this.getClass().getMethod("exit", Object.class), globalScope));

    String source;

    try {

      source = IOUtils.toString(globalScope.getClass().getClassLoader().getResourceAsStream("wait.js"));

    } catch (IOException e) {

      throw new ScriptusRuntimeException(e);

    }

        globalScope);

    Function wait_ctor = cx.compileFunction(globalScope, source, "wait_internal.js", 0, null);

    Function wait = (Function) wait_ctor.call(cx, globalScope, null, new Object[] { wait_intern, getLastPid });

   

           

            @Override

            public void write(OutputStream outputStream) throws IOException {

                Context cx = CommonJSEngine.enterContext();

                BoundFunction boundWrite = new BoundFunction(cx, scope, writeFunc, body, new Object[] {outputStream});

                Object[] args = {boundWrite};

                try {

                    forEach.call(cx, scope, body, args);

                } finally {