Examples with Realm com.github.anba.es6draft.runtime.Realm used on opensource projects

Example 1 with Realm

use of com.github.anba.es6draft.runtime.Realm in project es6draft by anba.

the class AtomicsTestFunctions method evalInWorker.

/**
     * shell-function: {@code evalInWorker(sourceString)}
     * 
     * @param cx
     *            the execution context
     * @param caller
     *            the caller execution context
     * @param sourceString
     *            the script source code
     * @return {@code true} if a new script worker was started, otherwise returns {@code false}
     */
@Function(name = "evalInWorker", arity = 1)
public boolean evalInWorker(ExecutionContext cx, ExecutionContext caller, String sourceString) {
    Source baseSource = Objects.requireNonNull(cx.getRealm().sourceInfo(caller));
    try {
        // TODO: Initialize extensions (console.jsm, window timers?).
        CompletableFuture.supplyAsync(() -> {
            // Set 'executor' to null so it doesn't get shared with the current runtime context.
            /* @formatter:off */
            RuntimeContext context = new RuntimeContext.Builder(cx.getRuntimeContext()).setExecutor(null).build();
            /* @formatter:on */
            World world = new World(context);
            Realm realm;
            try {
                realm = world.newInitializedRealm();
            } catch (IOException | URISyntaxException e) {
                throw new CompletionException(e);
            }
            // Bind test functions to this instance.
            realm.createGlobalProperties(this, AtomicsTestFunctions.class);
            // TODO: Add proper abstraction.
            ModuleLoader moduleLoader = world.getModuleLoader();
            if (moduleLoader instanceof NodeModuleLoader) {
                try {
                    ((NodeModuleLoader) moduleLoader).initialize(realm);
                } catch (IOException | URISyntaxException | MalformedNameException | ResolutionException e) {
                    throw new CompletionException(e);
                }
            }
            // Evaluate the script source code and then run pending jobs.
            Source source = new Source(baseSource, "evalInWorker-script", 1);
            Script script = realm.getScriptLoader().script(source, sourceString);
            Object result = script.evaluate(realm);
            world.runEventLoop();
            return result;
        }, cx.getRuntimeContext().getWorkerExecutor()).whenComplete((r, e) -> {
            if (e instanceof CompletionException) {
                Throwable cause = ((CompletionException) e).getCause();
                cx.getRuntimeContext().getWorkerErrorReporter().accept(cx, (cause != null ? cause : e));
            } else if (e != null) {
                cx.getRuntimeContext().getWorkerErrorReporter().accept(cx, e);
            }
        });
        return true;
    } catch (RejectedExecutionException e) {
        return false;
    }
}

Example 2 with Realm

use of com.github.anba.es6draft.runtime.Realm in project es6draft by anba.

the class MozShellFunctions method evalcx.

/**
     * shell-function: {@code evalcx(s, [o])}
     *
     * @param cx
     *            the execution context
     * @param caller
     *            the caller context
     * @param sourceCode
     *            the source to evaluate
     * @param o
     *            the global object
     * @return the eval result value
     */
@Function(name = "evalcx", arity = 1)
public Object evalcx(ExecutionContext cx, ExecutionContext caller, String sourceCode, Object o) {
    ScriptObject global;
    if (Type.isUndefinedOrNull(o)) {
        global = newGlobal(cx);
    } else {
        global = ToObject(cx, o);
    }
    if (sourceCode.isEmpty() || "lazy".equals(sourceCode)) {
        return global;
    }
    if (!(global instanceof GlobalObject)) {
        throw Errors.newError(cx, "invalid global argument");
    }
    Source source = new Source(cx.getRealm().sourceInfo(caller), "evalcx", 1);
    Realm realm = ((GlobalObject) global).getRealm();
    try {
        Script script = realm.getScriptLoader().script(source, sourceCode);
        return script.evaluate(realm);
    } catch (ParserException | CompilationException e) {
        // Create a script exception from the requested code realm, not from the caller's realm.
        throw e.toScriptException(realm.defaultContext());
    }
}

Example 3 with Realm

use of com.github.anba.es6draft.runtime.Realm in project es6draft by anba.

the class SharedFunctions method loadScript.

/**
     * Reads a file and evalutes its content.
     * 
     * @param cx
     *            the execution context
     * @param fileName
     *            the file name
     * @param path
     *            the file path
     * @throws ParserException
     *             if the source contains any syntax errors
     * @throws CompilationException
     *             if the parsed source cannot be compiled
     */
static void loadScript(ExecutionContext cx, Path fileName, Path path) throws ParserException, CompilationException {
    if (!Files.exists(path)) {
        throw new ScriptException(String.format("can't open '%s'", fileName.toString()));
    }
    try {
        Realm realm = cx.getRealm();
        Source source = new Source(path, fileName.toString(), 1);
        Script script = realm.getScriptLoader().script(source, path);
        script.evaluate(realm);
    } catch (IOException e) {
        throw Errors.newError(cx, Objects.toString(e.getMessage(), ""));
    }
}

Example 4 with Realm

use of com.github.anba.es6draft.runtime.Realm in project es6draft by anba.

the class InterpretedScriptBody method scriptEvaluation.

/**
     * 15.1.7 Runtime Semantics: ScriptEvaluation
     * 
     * @param cx
     *            the execution context
     * @param script
     *            the script object
     * @return the script evaluation result
     */
private Object scriptEvaluation(ExecutionContext cx, Script script) {
    Realm realm = cx.getRealm();
    /* step 1 (not applicable) */
    /* step 2 */
    LexicalEnvironment<GlobalEnvironmentRecord> globalEnv = realm.getGlobalEnv();
    /* steps 3-7 */
    ExecutionContext scriptCxt = newScriptExecutionContext(realm, script);
    /* steps 8-9 */
    ExecutionContext oldScriptContext = realm.getScriptContext();
    try {
        realm.setScriptContext(scriptCxt);
        /* step 10 */
        GlobalDeclarationInstantiation(scriptCxt, parsedScript, globalEnv);
        /* steps 11-12 */
        Object result = parsedScript.accept(new Interpreter(parsedScript), scriptCxt);
        /* step 16 */
        return result;
    } finally {
        /* steps 13-15  */
        realm.setScriptContext(oldScriptContext);
    }
}

Example 5 with Realm

use of com.github.anba.es6draft.runtime.Realm in project es6draft by anba.

the class NativeCode method getModuleExport.

/**
     * Resolves and returns the exported binding from a module record.
     * 
     * @param <T>
     *            the object type
     * @param module
     *            the module record
     * @param exportName
     *            the export name
     * @param clazz
     *            the expected class
     * @return the exported value
     * @throws IOException
     *             if there was any I/O error
     * @throws MalformedNameException
     *             if any imported module request cannot be normalized
     * @throws ResolutionException
     *             if any export binding cannot be resolved
     */
public static <T> T getModuleExport(ModuleRecord module, String exportName, Class<T> clazz) throws IOException, MalformedNameException, ResolutionException {
    ModuleExport export = module.resolveExport(exportName, new HashMap<>(), new HashSet<>());
    if (export == null) {
        throw new ResolutionException(Messages.Key.ModulesUnresolvedExport, exportName);
    }
    if (export.isAmbiguous()) {
        throw new ResolutionException(Messages.Key.ModulesAmbiguousExport, exportName);
    }
    ModuleRecord targetModule = export.getModule();
    if (!targetModule.isInstantiated() || !targetModule.isEvaluated()) {
        throw new IllegalStateException();
    }
    if (export.isNameSpaceExport()) {
        Realm realm = module.getRealm();
        if (realm == null) {
            throw new IllegalArgumentException();
        }
        ScriptObject namespace = GetModuleNamespace(realm.defaultContext(), targetModule);
        return clazz.cast(namespace);
    }
    LexicalEnvironment<?> targetEnv = targetModule.getEnvironment();
    if (targetEnv == null) {
        throw new ResolutionException(Messages.Key.UninitializedModuleBinding, export.getBindingName(), targetModule.getSourceCodeId().toString());
    }
    Object bindingValue = targetEnv.getEnvRec().getBindingValue(export.getBindingName(), true);
    return clazz.cast(bindingValue);
}