Exemple #1
0
 /**
  * Invoke a script from the command line.
  *
  * @param scriptResource the script resource of path
  * @param scriptArgs an array of command line arguments
  * @return the return value
  * @throws IOException an I/O related error occurred
  * @throws JavaScriptException the script threw an error during compilation or execution
  */
 public Object runScript(Object scriptResource, String... scriptArgs)
     throws IOException, JavaScriptException {
   Resource resource;
   if (scriptResource instanceof Resource) {
     resource = (Resource) scriptResource;
   } else if (scriptResource instanceof String) {
     resource = findResource((String) scriptResource, null, null);
   } else {
     throw new IOException("Unsupported script resource: " + scriptResource);
   }
   if (!resource.exists()) {
     throw new FileNotFoundException(scriptResource.toString());
   }
   Context cx = contextFactory.enterContext();
   try {
     Object retval;
     Map<Trackable, ReloadableScript> scripts = getScriptCache(cx);
     commandLineArgs = Arrays.asList(scriptArgs);
     ReloadableScript script = new ReloadableScript(resource, this);
     scripts.put(resource, script);
     mainScope = new ModuleScope(resource.getModuleName(), resource, globalScope, mainWorker);
     retval = mainWorker.evaluateScript(cx, script, mainScope);
     mainScope.updateExports();
     return retval instanceof Wrapper ? ((Wrapper) retval).unwrap() : retval;
   } finally {
     Context.exit();
   }
 }
Exemple #2
0
 /**
  * Evaluate an expression from the command line.
  *
  * @param expr the JavaScript expression to evaluate
  * @return the return value
  * @throws IOException an I/O related error occurred
  * @throws JavaScriptException the script threw an error during compilation or execution
  */
 public Object evaluateExpression(String expr) throws IOException, JavaScriptException {
   Context cx = contextFactory.enterContext();
   cx.setOptimizationLevel(-1);
   try {
     Object retval;
     Repository repository = repositories.get(0);
     Scriptable parentScope = mainScope != null ? mainScope : globalScope;
     ModuleScope scope = new ModuleScope("<expr>", repository, parentScope, mainWorker);
     Resource res = new StringResource("<expr>", expr, 1);
     ReloadableScript script = new ReloadableScript(res, this);
     retval = mainWorker.evaluateScript(cx, script, scope);
     return retval instanceof Wrapper ? ((Wrapper) retval).unwrap() : retval;
   } finally {
     Context.exit();
   }
 }
Exemple #3
0
  /**
   * Create a RhinoEngine with the given configuration. If <code>globals</code> is not null, its
   * contents are added as properties on the global object.
   *
   * @param config the configuration used to initialize the engine.
   * @param globals an optional map of global properties
   * @throws Exception if the engine can't be created
   */
  public RhinoEngine(RingoConfig config, Map<String, Object> globals) throws Exception {
    this.config = config;
    workers = new LinkedBlockingDeque<RingoWorker>();
    currentWorker = new ThreadLocal<RingoWorker>();
    mainWorker = new RingoWorker(this);
    compiledScripts = new ConcurrentHashMap<Trackable, ReloadableScript>();
    interpretedScripts = new ConcurrentHashMap<Trackable, ReloadableScript>();
    singletons = new HashMap<Singleton, Singleton>();
    contextFactory = new RingoContextFactory(this, config);
    repositories = config.getRepositories();
    wrapFactory = config.getWrapFactory();

    loaders =
        new ModuleLoader[] {new JsModuleLoader(), new JsonModuleLoader(), new ClassModuleLoader()};

    RingoDebugger debugger = null;
    if (config.getDebug()) {
      debugger = new RingoDebugger(config);
      debugger.setScopeProvider(this);
      debugger.attachTo(contextFactory);
      debugger.setBreakOnExceptions(true);
    }

    // create and initialize global scope
    Context cx = contextFactory.enterContext();
    try {
      boolean sealed = config.isSealed();
      globalScope = new RingoGlobal(cx, this, sealed);
      Class<Scriptable>[] classes = config.getHostClasses();
      if (classes != null) {
        for (Class<Scriptable> clazz : classes) {
          defineHostClass(clazz);
        }
      }
      ScriptableList.init(globalScope);
      ScriptableMap.init(globalScope);
      ScriptableObject.defineClass(globalScope, ScriptableWrapper.class);
      ScriptableObject.defineClass(globalScope, ModuleObject.class);
      if (globals != null) {
        for (Map.Entry<String, Object> entry : globals.entrySet()) {
          ScriptableObject.defineProperty(
              globalScope, entry.getKey(), entry.getValue(), ScriptableObject.DONTENUM);
        }
      }
      mainWorker.evaluateScript(cx, getScript("globals"), globalScope);
      evaluateBootstrapScripts(cx);
      if (sealed) {
        globalScope.sealObject();
      }
      if (debugger != null) {
        debugger.setBreak();
      }
      try {
        Runtime.getRuntime()
            .addShutdownHook(
                new Thread() {
                  public void run() {
                    shutdown();
                  }
                });
      } catch (java.security.AccessControlException e) {
        log.log(Level.WARNING, "Could not register shutdown hook due to security exception", e);
      }
    } finally {
      Context.exit();
    }
  }