/// <summary> /// https://tc39.es/ecma262/#sec-source-text-module-record-execute-module /// </summary> internal override Completion ExecuteModule(PromiseCapability capability = null) { var moduleContext = new ExecutionContext(this, _environment, _environment, null, _realm); if (!_hasTLA) { using (new StrictModeScope(true, force: true)) { _engine.EnterExecutionContext(moduleContext); var statementList = new JintStatementList(null, _source.Body); var result = statementList.Execute(_engine._activeEvaluationContext ?? new EvaluationContext(_engine)); //Create new evaluation context when called from e.g. module tests _engine.LeaveExecutionContext(); return(result); } } else { ExceptionHelper.ThrowNotImplementedException("async modules not implemented"); return(default);
/// <summary> /// Evaluates a script (expression) within the current execution context. /// </summary> /// <remarks> /// Internally, this is used for evaluating breakpoint conditions, but may also be used for e.g. watch lists /// in a debugger. /// </remarks> public JsValue Evaluate(Script script) { var context = _engine._activeEvaluationContext; if (context == null) { throw new DebugEvaluationException("Jint has no active evaluation context"); } int callStackSize = _engine.CallStack.Count; var list = new JintStatementList(null, script.Body); Completion result; try { result = list.Execute(context); } catch (Exception ex) { // An error in the evaluation may return a Throw Completion, or it may throw an exception: throw new DebugEvaluationException("An error occurred during debugger evaluation", ex); } finally { // Restore call stack while (_engine.CallStack.Count > callStackSize) { _engine.CallStack.Pop(); } } if (result.Type == CompletionType.Throw) { // TODO: Should we return an error here? (avoid exception overhead, since e.g. breakpoint // evaluation may be high volume. var error = result.GetValueOrDefault(); var ex = new JavaScriptException(error).SetCallstack(_engine, result.Location); throw new DebugEvaluationException("An error occurred during debugger evaluation", ex); } return(result.GetValueOrDefault()); }
// http://www.ecma-international.org/ecma-262/6.0/#sec-blockdeclarationinstantiation protected override Completion ExecuteInternal() { LexicalEnvironment oldEnv = null; if (_lexicalDeclarations != null) { oldEnv = _engine.ExecutionContext.LexicalEnvironment; var blockEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, _engine.ExecutionContext.LexicalEnvironment); JintStatementList.BlockDeclarationInstantiation(blockEnv, _lexicalDeclarations); _engine.UpdateLexicalEnvironment(blockEnv); } var blockValue = _statementList.Execute(); if (oldEnv != null) { _engine.UpdateLexicalEnvironment(oldEnv); } return(blockValue); }
protected override Completion ExecuteInternal(EvaluationContext context) { EnvironmentRecord oldEnv = null; var engine = context.Engine; if (_lexicalDeclarations != null) { oldEnv = engine.ExecutionContext.LexicalEnvironment; var blockEnv = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment); JintStatementList.BlockDeclarationInstantiation(engine, blockEnv, _lexicalDeclarations); engine.UpdateLexicalEnvironment(blockEnv); } var blockValue = _statementList.Execute(context); if (oldEnv is not null) { engine.UpdateLexicalEnvironment(oldEnv); } return(blockValue); }
protected override Completion ExecuteInternal() { return(_list.Execute()); }
protected override Completion ExecuteInternal(EvaluationContext context) { return(_list.Execute(context)); }