/**
* 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();
}
}
private void evaluateBootstrapScripts(Context cx) throws IOException {
List<String> bootstrapScripts = config.getBootstrapScripts();
if (bootstrapScripts != null) {
for (String script : bootstrapScripts) {
Resource resource = new FileResource(script);
// not found, attempt to resolve the file relative to ringo home
if (!resource.exists()) {
resource = getRingoHome().getResource(script);
}
if (resource == null || !resource.exists()) {
throw new FileNotFoundException("Bootstrap script " + script + " not found");
}
mainWorker.evaluateScript(cx, new ReloadableScript(resource, this), globalScope);
}
}
}
/**
* 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();
}
}
/**
* 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();
}
}