Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.dynjs.runtime;
  
  import org.dynjs.Clock;
  import org.dynjs.Config;
 
 import java.util.List;
 
 public class ExecutionContext implements CompilationContext {
 
     public static ExecutionContext createGlobalExecutionContext(DynJS runtime) {
         // 10.4.1.1
         LexicalEnvironment env = LexicalEnvironment.newGlobalEnvironment(runtime);
         return new ExecutionContext(runtimenullenvenvruntime.getGlobalContext().getObject(), false);
     }
 
     public static ExecutionContext createDefaultGlobalExecutionContext(DynJS runtime) {
         // 10.4.1.1
         LexicalEnvironment env = LexicalEnvironment.newGlobalEnvironment(runtime);
         ExecutionContext context = new ExecutionContext(runtimenullenvenvruntime.getGlobalContext().getObject(), false);
         context.blockManager = new BlockManager();
         return context;
     }
 
     public static ExecutionContext createGlobalExecutionContext(DynJS runtimeInitializationListener listener) {
         ExecutionContext context = ExecutionContext.createEvalExecutionContext(runtime);
         listener.initialize(context);
         return context;
     }
 
     public static ExecutionContext createEvalExecutionContext(DynJS runtime) {
         // 10.4.2 (no caller)
         return createGlobalExecutionContext(runtime);
     }
 
     private DynJS runtime;
     private ExecutionContext parent;
     private Object thisBinding;
     private boolean strict;
     private boolean inEval;
 
 
     private int lineNumber;
     private int columnNumber;
     private String fileName;
     private String debugContext = "<eval>";
     private VariableValues vars;
 
     // Just stash functions passed into this context with no processing.  IRScope will detect things like 'attributes' and
     // generate those on a case-by-case basis.
     private Object[] functionParameters;
 
     private Object functionReference;
 
     private List<StackElementthrowStack;
 
     private BlockManager blockManager;
 
     public ExecutionContext(DynJS runtimeExecutionContext parentLexicalEnvironment lexicalEnvironmentLexicalEnvironment variableEnvironmentObject thisBindingboolean strict) {
         this. = runtime;
         this. = parent;
         this. = lexicalEnvironment;
         this. = variableEnvironment;
         this. = thisBinding;
         this. = strict;
     }
 
     public void setFunctionParameters(Object[] args) {
         this. = args;
     }
 
     public Object[] getFunctionParameters() {
         return ;
     }
 
     public Object getFunctionParameter(int offset) {
         return getFunctionParameters()[offset];
     }
 
     public VariableValues getVars() {
         return ;
     }
 
     public VariableValues allocVars(int sizeVariableValues parent) {
          = new VariableValues(sizeparent);
 
        return ;
    }
    public Object getFunctionReference() {
        return this.;
    }
    public ExecutionContext getParent() {
        return this.;
    }
        return this.;
    }
        return this.;
    }
    public Object getThisBinding() {
        return this.;
    }
    public boolean isStrict() {
        return this.;
    }
    public boolean inEval() {
        return this.;
    }
    public Clock getClock() {
        return this..getConfig().getClock();
    }
    public TimeZone getTimeZone() {
        return this..getConfig().getTimeZone();
    }
    public Locale getLocale() {
        return this..getConfig().getLocale();
    }
    void setStrict(boolean strict) {
        this. = strict;
    }
    public Reference resolve(String name) {
        Reference result = this..getIdentifierReference(thisnameisStrict());
        return result;
    }
    public void setLineNumber(int lineNumber) {
        this. = lineNumber;
    }
    public int getLineNumber() {
        return this.;
    }
    public String getFileName() {
        return this.;
    }
    // ----------------------------------------------------------------------
    public Completion execute(JSProgram program) {
        BlockManager originalBlockManager = this.;
        try {
            this. = program.getBlockManager();
            ThreadContextManager.pushContext(this);
            setStrict(program.isStrict());
            this. = program.getFileName();
            performDeclarationBindingInstantiation(program);
            try {
                return program.execute(this);
            } catch (ThrowException e) {
                throw e;
            }
        } finally {
            ThreadContextManager.popContext();
            this. = originalBlockManager;
        }
    }
    public Object eval(JSProgram evalboolean direct) {
        BlockManager originalBlockManager = this.;
        try {
            ExecutionContext evalContext = createEvalExecutionContext(evaldirect);
            evalContext.blockManager = eval.getBlockManager();
            ThreadContextManager.pushContext(evalContext);
            Completion result = eval.execute(evalContext);
            return result.value;
        } finally {
            ThreadContextManager.popContext();
            this. = originalBlockManager;
        }
    }
    public Object call(JSFunction functionObject selfObject... args) {
        return call(nullfunctionselfargs);
    }
    public Object call(Object functionReferenceJSFunction functionObject selfObject... args) {
        // 13.2.1
        ExecutionContext fnContext = null;
        try {
            fnContext = createFunctionExecutionContext(functionReferencefunctionselfargs);
            ThreadContextManager.pushContext(fnContext);
            try {
                Object value = function.call(fnContext);
                if (value == null) {
                    return .;
                }
                return value;
            } catch (ThrowException e) {
                throw e;
            //} catch (Throwable e) {
//                throw new ThrowException(fnContext, e);
            }
        } catch (ThrowException t) {
            if (t.getCause() != null) {
                recordThrow(t.getCause(), fnContext);
            } else if ( t.getValue() instanceof Throwable ){
                recordThrow((Throwablet.getValue(), fnContext);
            }
            throw t;
        } catch (Throwable t) {
            recordThrowtfnContext );
            throw t;
        } finally {
            ThreadContextManager.popContext();
        }
    }
    public Object construct(Reference referenceObject... args) {
        Object value = reference.getValue(this);
        if (value instanceof JSFunction) {
            return construct(reference, (JSFunctionvalueargs);
        }
        return null;
    }
    //public Object construct(JSFunction function, Object... args) {
    //return construct( null, function, args );
    //}
    public Object construct(Object referenceJSFunction functionObject... args) {
        if (!function.isConstructor()) {
            throw new ThrowException(thiscreateTypeError("not a constructor"));
        }
        Object ctorName = function.get(this"name");
        if (ctorName == .) {
            if (reference instanceof Reference) {
                ctorName = ((Referencereference).getReferencedName();
            } else {
                ctorName = function.getDebugContext();
            }
        }
        // 13.2.2
        // 1. create the new object
        JSObject obj = function.createNewObject(this);
        // 2. set internal methods per 8.12 [DynObject]
        // 3. set class name [DynObject subclass (defaults true)]
        // 4. Set Extensible [DynObject subclass (defaults true)]
        // 5. Get the function's prototype
        // 6. If prototype is an object make that the new object's prototype
        // 7. If prototype is not an object set to the standard builtin object prototype 15.2.4 [AbstractJavascriptFunction]
        // [AbstractJavascriptFunction] handles #7, subclasses may handle #6 if necessary (see BuiltinArray#createNewObject)
        Object p = function.get(this"prototype");
        if (p != . && p instanceof JSObject) {
            obj.setPrototype((JSObjectp);
        } else {
            JSObject defaultObjectProto = getPrototypeFor("Object");
            obj.setPrototype(defaultObjectProto);
        }
        // 8. Call the function with obj as self
        Object result = call(referencefunctionobjargs);
        // 9. If result is a JSObject return it
        if (result instanceof JSObject) {
            obj = (JSObjectresult;
        }
        // Otherwise return obj
        return obj;
    }
    protected void recordThrow(Throwable tExecutionContext fnContext) {
        if (this. == null) {
            this. = new ArrayList<StackElement>();
            this..add(fnContext.getStackElement());
        } else {
            // handled lower
        }
    }
    public boolean isThrowInProgress() {
        return this. != null && !this..isEmpty();
    }
    public List<StackElementgetThrowStack() {
        return this.;
    }
    public void addThrowStack(List<StackElementthrowStack) {
        if (this. == null) {
            this. = new ArrayList<>();
        }
        this..addAll(throwStack);
    }
    // ----------------------------------------------------------------------
    public ExecutionContext createEvalExecutionContext(JSProgram evalboolean direct) {
        // 10.4.2 (with caller)
        ExecutionContext context = null;
        Object evalThisBinding = null;
        LexicalEnvironment evalLexEnv = null;
        LexicalEnvironment evalVarEnv = null;
        if (!direct) {
            evalThisBinding = getGlobalContext();
            evalLexEnv = LexicalEnvironment.newGlobalEnvironment(getGlobalContext().getObject());
            evalVarEnv = LexicalEnvironment.newGlobalEnvironment(getGlobalContext().getObject());
        } else {
            evalThisBinding = this.;
            evalLexEnv = this.getLexicalEnvironment();
            evalVarEnv = this.getVariableEnvironment();
        }
        if (eval.isStrict()) {
            LexicalEnvironment strictVarEnv = LexicalEnvironment.newDeclarativeEnvironment(this.getLexicalEnvironment());
            evalLexEnv = strictVarEnv;
            evalVarEnv = strictVarEnv;
        }
        context = new ExecutionContext(this.thisevalLexEnvevalVarEnvevalThisBindingeval.isStrict());
        context.performFunctionDeclarationBindings(evaltrue);
        context.performVariableDeclarationBindings(evaltrue);
        context.fileName = eval.getFileName();
        return context;
    }
    public ExecutionContext createFunctionExecutionContext(Object functionReferenceJSFunction functionObject thisArgObject... arguments) {
        // 10.4.3
        Object thisBinding = null;
        if (function.isStrict()) {
            thisBinding = thisArg;
        } else {
            if (thisArg == null || thisArg == . || thisArg == .) {
                thisBinding = getGlobalContext().getObject();
            } else if (!(thisArg instanceof JSObject)) {
                // thisBinding = Types.toObject(this, thisArg);
                thisBinding = Types.toThisObject(thisthisArg);
            } else {
                thisBinding = thisArg;
            }
        }
        LexicalEnvironment scope = function.getScope();
        LexicalEnvironment localEnv = LexicalEnvironment.newDeclarativeEnvironment(scope);
        ExecutionContext context = new ExecutionContext(this.thislocalEnvlocalEnvthisBindingfunction.isStrict());
        if (!(function instanceof IRJSFunction && !(function instanceof JITCompiler.CompiledFunction))) {
            context.performDeclarationBindingInstantiation(functionarguments);
        }
        context.fileName = function.getFileName();
        // System.err.println( "debug null: " + ( function.getDebugContext() == null ? function : "not null") );
        context.debugContext = function.getDebugContext();
        context.functionReference = functionReference;
        context.setFunctionParameters(arguments);
        return context;
    }
    public Completion executeCatch(BasicBlock blockString identifierObject thrown) {
        // 12.14
        if (thrown instanceof Throwable && this. != null && ! this..isEmpty()) {
            StackTraceElement[] originalStack = ((Throwable)thrown).getStackTrace();
            List<StackTraceElementnewStack = new ArrayList<>();
            for ( int i = 0 ; i < originalStack.length ; ++i ) {
                String cn = originalStack[i].getClassName();
                if (cn.startsWith("org.dynjs") || cn.startsWith"java.lang.invoke" )) {
                    break;
                }
                newStack.addoriginalStack[i] );
            }
            int throwLen = this..size();
            for ( int i = throwLen - 1 ; i >= 0 ; --i ) {
                newStack.add.get(i).toStackTraceElement() );
            }
            ((Throwable)thrown).setStackTrace(newStack.toArraynew StackTraceElement[0]));
        }
        LexicalEnvironment oldEnv = this.;
        LexicalEnvironment catchEnv = LexicalEnvironment.newDeclarativeEnvironment(oldEnv);
        catchEnv.getRecord().createMutableBinding(thisidentifierfalse);
        catchEnv.getRecord().setMutableBinding(thisidentifierthrownfalse);
        try {
            this. = catchEnv;
            return block.call(this);
        } catch (ThrowException e) {
            throw e;
        } catch (Throwable t) {
            throw new ThrowException(thist);
        } finally {
            this. = oldEnv;
        }
    }
    public Completion executeWith(JSObject withObjBasicBlock block) {
        LexicalEnvironment oldEnv = this.;
        LexicalEnvironment withEnv = LexicalEnvironment.newObjectEnvironment(withObjtrueoldEnv);
        try {
            this. = withEnv;
            return block.call(this);
        } finally {
            this. = oldEnv;
        }
    }
    private void performDeclarationBindingInstantiation(JSProgram program) {
        performFunctionDeclarationBindings(programfalse);
        performVariableDeclarationBindings(programfalse);
    }
    private void performDeclarationBindingInstantiation(JSFunction functionObject[] arguments) {
        // 10.5 (Functions)
        String[] names = function.getFormalParameters();
        Object v = null;
        // * 4
        for (int i = 0; i < names.length; ++i) {
            if ((i + 1) > arguments.length) {
                v = .;
            } else {
                v = arguments[i];
            }
            env.assignMutableBinding(thisnames[i], vfalsefunction.isStrict());
        }
        // * 5
        performFunctionDeclarationBindings(functionfalse);
        // * 6
        if (!env.hasBinding(this"arguments")) {
            // * 7
            Arguments argsObj = createArgumentsObject(functionarguments);
            if (function.isStrict()) {
                env.createImmutableBinding("arguments");
                env.initializeImmutableBinding("arguments"argsObj);
            } else {
                env.createMutableBinding(this"arguments"false);
                env.setMutableBinding(this"arguments"argsObjfalse);
            }
        }
        // * 8
        performVariableDeclarationBindings(functionfalse);
    }
    private Arguments createArgumentsObject(final JSFunction functionfinal Object[] arguments) {
        // 10.6
        Arguments obj = new Arguments(getGlobalContext());
        obj.defineOwnProperty(this"length",
                PropertyDescriptor.newDataPropertyDescriptor(arguments.lengthtruetruefalse), false);
        String[] names = function.getFormalParameters();
        JSObject map = new DynObject(getGlobalContext());
        List<StringmappedNames = new ArrayList<>();
        final LexicalEnvironment env = getVariableEnvironment();
        for (int i = 0; i < arguments.length; ++i) {
            final Object val = arguments[i];
            obj.defineOwnProperty(this"" + i,
                    PropertyDescriptor.newDataPropertyDescriptor(valtruetruetrue), false);
            if (i < names.length) {
                if (!function.isStrict()) {
                    final String name = names[i];
                    if (i < names.length) {
                        if (!mappedNames.contains(name)) {
                            mappedNames.add(name);
                            PropertyDescriptor desc = new PropertyDescriptor();
                            desc.setSetter(new ArgSetter(getGlobalContext(), envname));
                            desc.setGetter(new ArgGetter(getGlobalContext(), envname));
                            desc.setConfigurable(true);
                            map.defineOwnProperty(this"" + idescfalse);
                        }
                    }
                }
            }
        }
        if (!mappedNames.isEmpty()) {
            obj.setParameterMap(map);
        }
        if (function.isStrict()) {
            final JSFunction thrower = getGlobalContext().getThrowTypeError();
            obj.defineOwnProperty(this"caller",
                    PropertyDescriptor.newAccessorPropertyDescriptor(throwerthrower), false);
            obj.defineOwnProperty(this"callee",
                    PropertyDescriptor.newAccessorPropertyDescriptor(throwerthrower), false);
        } else {
            obj.defineOwnProperty(this"callee",
                    PropertyDescriptor.newDataPropertyDescriptor(functiontruetruefalse), false);
        }
        return obj;
    }
    private void performFunctionDeclarationBindings(final JSCode codefinal boolean configurableBindings) {
        // 10.5 Function Declaration Binding
        List<FunctionDeclarationdecls = code.getFunctionDeclarations();
        EnvironmentRecord env = this..getRecord();
        for (FunctionDeclaration each : decls) {
            String identifier = each.getIdentifier();
            if (!env.hasBinding(thisidentifier)) {
                env.createMutableBinding(thisidentifierconfigurableBindings);
            } else if (env.isGlobal()) {
                JSObject globalObject = ((ObjectEnvironmentRecordenv).getBindingObject();
                PropertyDescriptor existingProp = (PropertyDescriptorglobalObject.getProperty(thisidentifierfalse);
                if (existingProp.isConfigurable()) {
                    globalObject.defineOwnProperty(thisidentifier,
                            PropertyDescriptor.newDataPropertyDescriptor(.trueconfigurableBindingstrue), true);
                } else if (existingProp.isAccessorDescriptor() || (!existingProp.isWritable() && !existingProp.isEnumerable())) {
                    throw new ThrowException(thiscreateTypeError("unable to bind function '" + identifier + "'"));
                }
            }
            JSFunction function = getCompiler().compileFunction(thisidentifiereach.getFormalParameters(), each.getBlock(), each.isStrict());
            function.setDebugContext(identifier);
            env.setMutableBinding(thisidentifierfunctioncode.isStrict());
        }
    }
    private void performVariableDeclarationBindings(final JSCode codefinal boolean configurableBindings) {
        List<VariableDeclarationdecls = code.getVariableDeclarations();
        EnvironmentRecord env = this..getRecord();
        for (VariableDeclaration decl : decls) {
            String identifier = decl.getIdentifier();
            if (!env.hasBinding(thisidentifier)) {
                env.createMutableBinding(thisidentifierconfigurableBindings);
                env.setMutableBinding(thisidentifier.code.isStrict());
            }
        }
    }
    public Config getConfig() {
        return this..getConfig();
    }
    public GlobalContext getGlobalContext() {
        return this..getGlobalContext();
    }
    public JSCompiler getCompiler() {
        return this..getCompiler();
    }
    public BlockManager getBlockManager() {
        if ( this. != null ) {
            return this.;
        }
        if ( this. != null ) {
            return this..getBlockManager();
        }
        return null;
    }
    public DynJS getRuntime() {
        return this.;
    }
    public Reference createPropertyReference(Object baseString propertyName) {
        return new Reference(propertyNamebaseisStrict());
    }
    public Entry retrieveBlockEntry(int statementNumber) {
        return getBlockManager().retrievestatementNumber );
    }
    public JSObject createTypeError(String message) {
        return createError("TypeError"message);
    }
    public JSObject createReferenceError(String message) {
        return createError("ReferenceError"message);
    }
    public JSObject createRangeError(String message) {
        return createError("RangeError"message);
    }
    public JSObject createSyntaxError(String message) {
        return createError("SyntaxError"message);
    }
    public JSObject createUriError(String message) {
        return createError("URIError"message);
    }
    public JSObject createError(String typeString message) {
        JSFunction func = getGlobalContext().getType(type);
        JSObject err = null;
        if (message == null) {
            err = (JSObjectconstruct((Objectnullfunc);
        } else {
            err = (JSObjectconstruct((Objectnullfuncmessage);
        }
        err.put(this"__native"truefalse);
        return err;
    }
    public void collectStackElements(List<StackElementelements) {
        elements.add(getStackElement());
        if ( != null) {
            .collectStackElements(elements);
        }
    }
    public StackElement getStackElement() {
        String locationContext = this.;
        if ( locationContext.equals"<anonymous>" ) ) {
            if ( this. != null && this. instanceof Reference ) {
                locationContext = ((Referencethis.).getReferencedName();
            }
        }
        return new StackElement(locationContextthis);
    }
    public JSObject getPrototypeFor(String type) {
        return getGlobalContext().getPrototypeFor(type);
    }
    public String toString() {
        return "ExecutionContext: " + System.identityHashCode(this);// + "; parent=" + this.parent;
    }
        return getRuntime().getConfig().getClassLoader();
    }
    public void setColumnNumber(int column) {
        this. = column;
    }
    public int getColumnNumber() {
        return this.;
    }
    public void inEval(boolean b) {
        this. = b;
    }
New to GrepCode? Check out our FAQ X