/// <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));
}
