/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-12.14 /// </summary> /// <param name="tryStatement"></param> /// <returns></returns> public Completion ExecuteTryStatement(TryStatement tryStatement) { var b = ExecuteStatement(tryStatement.Block); if (b.Type == Completion.Throw) { // execute catch if (tryStatement.Handlers.Any()) { for (int i = 0, len = tryStatement.Handlers.Count; i < len; i++) { var catchClause = tryStatement.Handlers[i]; var c = _engine.GetValue(b); var oldEnv = _engine.ExecutionContext.LexicalEnvironment; var catchEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv); catchEnv.Record.CreateMutableBinding(catchClause.Param.Name); catchEnv.Record.SetMutableBinding(catchClause.Param.Name, c, false); _engine.ExecutionContext.LexicalEnvironment = catchEnv; b = ExecuteStatement(catchClause.Body); _engine.ExecutionContext.LexicalEnvironment = oldEnv; } } } if (tryStatement.Finalizer != null) { var f = ExecuteStatement(tryStatement.Finalizer); if (f.Type == Completion.Normal) { return(b); } return(f); } return(b); }
public JsValue EvaluateFunctionExpression(FunctionExpression functionExpression) { var funcEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, _engine.ExecutionContext.LexicalEnvironment); var envRec = (DeclarativeEnvironmentRecord)funcEnv.Record; if (functionExpression.Id != null && !String.IsNullOrEmpty(functionExpression.Id.Name)) { envRec.CreateMutableBinding(functionExpression.Id.Name); } var closure = new ScriptFunctionInstance( _engine, functionExpression, funcEnv, functionExpression.Strict ); if (functionExpression.Id != null && !String.IsNullOrEmpty(functionExpression.Id.Name)) { envRec.InitializeImmutableBinding(functionExpression.Id.Name, closure); } return(closure); }
public Engine(Action <Options> options) { _executionContexts = new Stack <ExecutionContext>(); Global = GlobalObject.CreateGlobalObject(this); Object = ObjectConstructor.CreateObjectConstructor(this); Function = FunctionConstructor.CreateFunctionConstructor(this); Array = ArrayConstructor.CreateArrayConstructor(this); String = StringConstructor.CreateStringConstructor(this); RegExp = RegExpConstructor.CreateRegExpConstructor(this); Number = NumberConstructor.CreateNumberConstructor(this); Boolean = BooleanConstructor.CreateBooleanConstructor(this); Date = DateConstructor.CreateDateConstructor(this); Math = MathInstance.CreateMathObject(this); Json = JsonInstance.CreateJsonObject(this); Error = ErrorConstructor.CreateErrorConstructor(this, "Error"); EvalError = ErrorConstructor.CreateErrorConstructor(this, "EvalError"); RangeError = ErrorConstructor.CreateErrorConstructor(this, "RangeError"); ReferenceError = ErrorConstructor.CreateErrorConstructor(this, "ReferenceError"); SyntaxError = ErrorConstructor.CreateErrorConstructor(this, "SyntaxError"); TypeError = ErrorConstructor.CreateErrorConstructor(this, "TypeError"); UriError = ErrorConstructor.CreateErrorConstructor(this, "URIError"); // Because the properties might need some of the built-in object // their configuration is delayed to a later step Global.Configure(); Object.Configure(); Object.PrototypeObject.Configure(); Function.Configure(); Function.PrototypeObject.Configure(); Array.Configure(); Array.PrototypeObject.Configure(); String.Configure(); String.PrototypeObject.Configure(); RegExp.Configure(); RegExp.PrototypeObject.Configure(); Number.Configure(); Number.PrototypeObject.Configure(); Boolean.Configure(); Boolean.PrototypeObject.Configure(); Date.Configure(); Date.PrototypeObject.Configure(); Math.Configure(); Json.Configure(); Error.Configure(); Error.PrototypeObject.Configure(); // create the global environment http://www.ecma-international.org/ecma-262/5.1/#sec-10.2.3 GlobalEnvironment = new LexicalEnvironment(); GlobalEnvironment.Setup(new ObjectEnvironmentRecord(this, Global, false), null); // create the global execution context http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.1.1 EnterExecutionContext(GlobalEnvironment, GlobalEnvironment, Global); Options = new Options(); if (options != null) { options(Options); } Eval = new EvalFunctionInstance(this, new string[0], LexicalEnvironment.NewDeclarativeEnvironment(this, ExecutionContext.LexicalEnvironment), StrictModeScope.IsStrictModeCode); Global.FastAddProperty("eval", Eval, true, false, true); _statements = new StatementInterpreter(this); _expressions = new ExpressionInterpreter(this); if (Options._IsClrAllowed) { Global.FastAddProperty("System", new NamespaceReference(this, "System"), false, false, false); Global.FastAddProperty("importNamespace", new ClrFunctionInstance(this, (thisObj, arguments) => { return(new NamespaceReference(this, TypeConverter.ToString(arguments.At(0)))); }), false, false, false); } ClrTypeConverter = new DefaultTypeConverter(this); BreakPoints = new List <BreakPoint>(); DebugHandler = new DebugHandler(this); }
public JsValue Call(JsValue thisObject, JsValue[] arguments, bool directCall) { if (arguments.At(0).Type != Types.String) { return(arguments.At(0)); } var code = TypeConverter.ToString(arguments.At(0)); try { var parser = new JavaScriptParser(StrictModeScope.IsStrictModeCode); var program = parser.Parse(code); using (new StrictModeScope(program.Strict)) { using (new EvalCodeScope()) { LexicalEnvironment strictVarEnv = null; try { if (!directCall) { Engine.EnterExecutionContext(Engine.GlobalEnvironment, Engine.GlobalEnvironment, Engine.Global); } if (StrictModeScope.IsStrictModeCode) { strictVarEnv = LexicalEnvironment.NewDeclarativeEnvironment(Engine, Engine.ExecutionContext.LexicalEnvironment); Engine.EnterExecutionContext(strictVarEnv, strictVarEnv, Engine.ExecutionContext.ThisBinding); } Engine.DeclarationBindingInstantiation(DeclarationBindingType.EvalCode, program.FunctionDeclarations, program.VariableDeclarations, this, arguments); var result = _engine.ExecuteStatement(program); if (result.Type == Completion.Throw) { throw result.Exception ?? new JavaScriptException(result.GetValueOrDefault()) .SetCallstack(_engine, result.Location); } else { return(result.GetValueOrDefault()); } } finally { if (strictVarEnv != null) { Engine.LeaveExecutionContext(); } if (!directCall) { Engine.LeaveExecutionContext(); } } } } } catch (ParserException) { throw new JavaScriptException(Engine.SyntaxError); } }
public ObjectInstance Construct(JsValue[] arguments) { var argCount = arguments.Length; string p = ""; string body = ""; if (argCount == 1) { body = TypeConverter.ToString(arguments[0]); } else if (argCount > 1) { var firstArg = arguments[0]; p = TypeConverter.ToString(firstArg); for (var k = 1; k < argCount - 1; k++) { var nextArg = arguments[k]; p += "," + TypeConverter.ToString(nextArg); } body = TypeConverter.ToString(arguments[argCount - 1]); } var parameters = this.ParseArgumentNames(p); var parser = new JavaScriptParser(); FunctionExpression function; try { var functionExpression = "function(" + p + ") { " + body + "}"; function = parser.ParseFunctionExpression(functionExpression); } catch (ParserException) { throw new JavaScriptException(Engine.SyntaxError); } // todo: check if there is not a way to use the FunctionExpression directly instead of creating a FunctionDeclaration var functionObject = new ScriptFunctionInstance( Engine, new FunctionDeclaration { Type = SyntaxNodes.FunctionDeclaration, Body = new BlockStatement { Type = SyntaxNodes.BlockStatement, Body = new [] { function.Body } }, Parameters = parameters.Select(x => new Identifier { Type = SyntaxNodes.Identifier, Name = x }).ToArray(), FunctionDeclarations = function.FunctionDeclarations, VariableDeclarations = function.VariableDeclarations }, LexicalEnvironment.NewDeclarativeEnvironment(Engine, Engine.ExecutionContext.LexicalEnvironment), function.Strict ) { Extensible = true }; return(functionObject); }
/// <summary> /// https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset /// </summary> private Completion BodyEvaluation( JintExpression lhs, JintStatement stmt, IIterator iteratorRecord, IterationKind iterationKind, LhsKind lhsKind, IteratorKind iteratorKind = IteratorKind.Sync) { var oldEnv = _engine.ExecutionContext.LexicalEnvironment; var v = Undefined.Instance; var destructuring = _destructuring; string lhsName = null; var completionType = CompletionType.Normal; var close = false; try { while (true) { LexicalEnvironment iterationEnv = null; if (!iteratorRecord.TryIteratorStep(out var nextResult)) { close = true; return(new Completion(CompletionType.Normal, v, null, Location)); } if (iteratorKind == IteratorKind.Async) { // nextResult = await nextResult; } var nextValue = nextResult.Get(CommonProperties.Value); close = true; Reference lhsRef = null; if (lhsKind != LhsKind.LexicalBinding) { if (!destructuring) { lhsRef = (Reference)lhs.Evaluate(); } } else { iterationEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv); if (_tdzNames != null) { BindingInstantiation(iterationEnv); } _engine.UpdateLexicalEnvironment(iterationEnv); if (!destructuring) { if (lhsName == null) { lhsName = ((Identifier)((VariableDeclaration)_leftNode).Declarations[0].Id).Name; } lhsRef = _engine.ResolveBinding(lhsName); } } if (!destructuring) { // If lhsRef is an abrupt completion, then // Let status be lhsRef. if (lhsKind == LhsKind.LexicalBinding) { lhsRef.InitializeReferencedBinding(nextValue); } else { _engine.PutValue(lhsRef, nextValue); } } else { BindingPatternAssignmentExpression.ProcessPatterns( _engine, _assignmentPattern, nextValue, iterationEnv, checkObjectPatternPropertyReference: _lhsKind != LhsKind.VarBinding); if (lhsKind == LhsKind.Assignment) { // DestructuringAssignmentEvaluation of assignmentPattern using nextValue as the argument. } else if (lhsKind == LhsKind.VarBinding) { // BindingInitialization for lhs passing nextValue and undefined as the arguments. } else { // BindingInitialization for lhs passing nextValue and iterationEnv as arguments } } var result = stmt.Execute(); _engine.UpdateLexicalEnvironment(oldEnv); if (!ReferenceEquals(result.Value, null)) { v = result.Value; } if (result.Type == CompletionType.Break && (result.Identifier == null || result.Identifier == _statement?.LabelSet?.Name)) { return(new Completion(CompletionType.Normal, v, null, Location)); } if (result.Type != CompletionType.Continue || (result.Identifier != null && result.Identifier != _statement?.LabelSet?.Name)) { if (result.Type != CompletionType.Normal) { return(result); } } } } catch { completionType = CompletionType.Throw; throw; } finally { if (close) { iteratorRecord.Close(completionType); } _engine.UpdateLexicalEnvironment(oldEnv); } }
/// <summary> /// https://tc39.es/ecma262/#sec-performeval /// </summary> public JsValue Call(JsValue thisObject, JsValue[] arguments, bool direct) { if (!(arguments.At(0) is JsString x)) { return(arguments.At(0)); } var parser = new JavaScriptParser(x.ToString(), ParserOptions); Script script; try { script = parser.ParseScript(StrictModeScope.IsStrictModeCode); } catch (ParserException e) { return(e.Description == Messages.InvalidLHSInAssignment ? ExceptionHelper.ThrowReferenceError <JsValue>(_engine) : ExceptionHelper.ThrowSyntaxError <JsValue>(_engine)); } var body = script.Body; if (body.Count == 0) { return(Undefined); } var strictEval = script.Strict || _engine._isStrict; var ctx = _engine.ExecutionContext; using (new StrictModeScope(strictEval)) { LexicalEnvironment lexEnv; LexicalEnvironment varEnv; if (direct) { lexEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, ctx.LexicalEnvironment); varEnv = ctx.VariableEnvironment; } else { lexEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, Engine.GlobalEnvironment); varEnv = Engine.GlobalEnvironment; } if (strictEval) { varEnv = lexEnv; } // If ctx is not already suspended, suspend ctx. Engine.EnterExecutionContext(lexEnv, varEnv); try { Engine.EvalDeclarationInstantiation(script, varEnv, lexEnv, strictEval); var statement = new JintScript(_engine, script); var result = statement.Execute(); var value = result.GetValueOrDefault(); if (result.Type == CompletionType.Throw) { var ex = new JavaScriptException(value).SetCallstack(_engine, result.Location); throw ex; } else { return(value); } } finally { Engine.LeaveExecutionContext(); } } }
public Engine(Action <Options> options) { _executionContexts = new ExecutionContextStack(); Global = GlobalObject.CreateGlobalObject(this); Object = ObjectConstructor.CreateObjectConstructor(this); Function = FunctionConstructor.CreateFunctionConstructor(this); Symbol = SymbolConstructor.CreateSymbolConstructor(this); Array = ArrayConstructor.CreateArrayConstructor(this); Map = MapConstructor.CreateMapConstructor(this); Set = SetConstructor.CreateSetConstructor(this); Iterator = IteratorConstructor.CreateIteratorConstructor(this); String = StringConstructor.CreateStringConstructor(this); RegExp = RegExpConstructor.CreateRegExpConstructor(this); Number = NumberConstructor.CreateNumberConstructor(this); Boolean = BooleanConstructor.CreateBooleanConstructor(this); // Date = DateConstructor.CreateDateConstructor(this); Math = MathInstance.CreateMathObject(this); Json = JsonInstance.CreateJsonObject(this); Error = ErrorConstructor.CreateErrorConstructor(this, "Error"); EvalError = ErrorConstructor.CreateErrorConstructor(this, "EvalError"); RangeError = ErrorConstructor.CreateErrorConstructor(this, "RangeError"); ReferenceError = ErrorConstructor.CreateErrorConstructor(this, "ReferenceError"); SyntaxError = ErrorConstructor.CreateErrorConstructor(this, "SyntaxError"); TypeError = ErrorConstructor.CreateErrorConstructor(this, "TypeError"); UriError = ErrorConstructor.CreateErrorConstructor(this, "URIError"); GlobalSymbolRegistry = new GlobalSymbolRegistry(); // Because the properties might need some of the built-in object // their configuration is delayed to a later step Global.Configure(); Object.Configure(); Object.PrototypeObject.Configure(); Symbol.Configure(); Symbol.PrototypeObject.Configure(); Function.Configure(); Function.PrototypeObject.Configure(); Array.Configure(); Array.PrototypeObject.Configure(); Map.Configure(); Map.PrototypeObject.Configure(); Set.Configure(); Set.PrototypeObject.Configure(); Iterator.Configure(); Iterator.PrototypeObject.Configure(); String.Configure(); String.PrototypeObject.Configure(); RegExp.Configure(); RegExp.PrototypeObject.Configure(); Number.Configure(); Number.PrototypeObject.Configure(); Boolean.Configure(); Boolean.PrototypeObject.Configure(); // Date.Configure(); // Date.PrototypeObject.Configure(); Math.Configure(); Json.Configure(); Error.Configure(); Error.PrototypeObject.Configure(); // create the global environment http://www.ecma-international.org/ecma-262/5.1/#sec-10.2.3 GlobalEnvironment = LexicalEnvironment.NewObjectEnvironment(this, Global, null, false); // create the global execution context http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.1.1 EnterExecutionContext(GlobalEnvironment, GlobalEnvironment, Global); Options = new Options(); options?.Invoke(Options); // gather some options as fields for faster checks _isDebugMode = Options.IsDebugMode; if (_isDebugMode) { MyAPIGateway.Utilities.ShowMessage("SpaceJS", "Debug mode enabled."); } _isStrict = Options.IsStrict; _maxStatements = Options._MaxStatements; _referenceResolver = Options.ReferenceResolver; _memoryLimit = Options._MemoryLimit; _runBeforeStatementChecks = (_maxStatements > 0 && _maxStatements < int.MaxValue) || Options._TimeoutInterval.Ticks > 0 || _memoryLimit > 0 || _isDebugMode; _referencePool = new ReferencePool(); _argumentsInstancePool = new ArgumentsInstancePool(this); _jsValueArrayPool = new JsValueArrayPool(); Eval = new EvalFunctionInstance(this, System.ArrayExt.Empty <string>(), LexicalEnvironment.NewDeclarativeEnvironment(this, ExecutionContext.LexicalEnvironment), StrictModeScope.IsStrictModeCode); Global.FastAddProperty("eval", Eval, true, false, true); _statements = new StatementInterpreter(this); _expressions = new ExpressionInterpreter(this); /* if (Options._IsClrAllowed) * { * Global.FastAddProperty("System", new NamespaceReference(this, "System"), false, false, false); * Global.FastAddProperty("importNamespace", new ClrFunctionInstance( * this, * "importNamespace", * (thisObj, arguments) => new NamespaceReference(this, TypeConverter.ToString(arguments.At(0)))), false, false, false); * } */ // ClrTypeConverter = new DefaultTypeConverter(this); }
public Completion Execute(JsValue input) { if (!_initialized) { Initialize(); _initialized = true; } JsValue v = Undefined.Instance; Location l = _engine._lastSyntaxNode.Location; JintSwitchCase defaultCase = null; bool hit = false; for (var i = 0; i < (uint)_jintSwitchBlock.Length; i++) { var clause = _jintSwitchBlock[i]; LexicalEnvironment oldEnv = null; if (clause.LexicalDeclarations != null) { oldEnv = _engine.ExecutionContext.LexicalEnvironment; var blockEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv); JintStatementList.BlockDeclarationInstantiation(blockEnv, clause.LexicalDeclarations); _engine.UpdateLexicalEnvironment(blockEnv); } if (clause.Test == null) { defaultCase = clause; } else { var clauseSelector = clause.Test.GetValue(); if (JintBinaryExpression.StrictlyEqual(clauseSelector, input)) { hit = true; } } if (hit && clause.Consequent != null) { var r = clause.Consequent.Execute(); if (oldEnv != null) { _engine.UpdateLexicalEnvironment(oldEnv); } if (r.Type != CompletionType.Normal) { return(r); } l = r.Location; v = r.Value ?? Undefined.Instance; } } // do we need to execute the default case ? if (hit == false && defaultCase != null) { LexicalEnvironment oldEnv = null; if (defaultCase.LexicalDeclarations != null) { oldEnv = _engine.ExecutionContext.LexicalEnvironment; var blockEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv); JintStatementList.BlockDeclarationInstantiation(blockEnv, defaultCase.LexicalDeclarations); _engine.UpdateLexicalEnvironment(blockEnv); } var r = defaultCase.Consequent.Execute(); if (oldEnv != null) { _engine.UpdateLexicalEnvironment(oldEnv); } if (r.Type != CompletionType.Normal) { return(r); } l = r.Location; v = r.Value ?? Undefined.Instance; } return(new Completion(CompletionType.Normal, v, null, l)); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-12.14 /// </summary> /// <param name="tryStatement"></param> /// <returns></returns> public void ExecuteTryStatement(RuntimeState state) { TryStatement tryStatement = (TryStatement)state.arg; ExecuteTryStatementLocal local; if (state.local == null) { state.local = local = new ExecuteTryStatementLocal(); local.stage = 0; } else { local = (ExecuteTryStatementLocal)state.local; } if (local.stage == 0) { if (state.calleeReturned) { state.calleeReturned = false; local.stage = 1; local.b = (Completion)state.calleeReturnValue; return; } Call(_engine.ExecuteStatement, tryStatement.Block); return; } if (local.stage == 1) { if (state.calleeReturned) { state.calleeReturned = false; local.stage = 2; local.b = (Completion)state.calleeReturnValue; return; } var catchClause = tryStatement.Handler; if (catchClause != null) { var c = local.b.Value; local.oldEnv = _engine.ExecutionContext.LexicalEnvironment; var catchEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, local.oldEnv); catchEnv._record.CreateMutableBinding(((Identifier)catchClause.Param).Name, c); _engine.UpdateLexicalEnvironment(catchEnv); Call(_engine.ExecuteStatement, catchClause.Body); return; } local.stage = 2; } if (local.stage == 2) { if (state.calleeReturned) { var f = (Completion)state.calleeReturnValue; if (f.Type == CompletionType.Normal) { Return(local.b); return; } Return(f); return; } if (tryStatement.Finalizer != null) { Call(_engine.ExecuteStatement, tryStatement.Finalizer); return; } Return(local.b); return; } }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-13.2.1 /// </summary> /// <param name="thisArg"></param> /// <param name="arguments"></param> /// <returns></returns> public override JsValue Call(JsValue thisArg, JsValue[] arguments) { var scope = Engine.PoolStrictMode.Get(); scope.Setup(Strict, true); { // setup new execution context http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.3 JsValue thisBinding; if (StrictModeScope.IsStrictModeCode) { thisBinding = thisArg; } else if (thisArg == Undefined.Instance || thisArg == Null.Instance) { thisBinding = Engine.Global; } else if (!thisArg.IsObject()) { thisBinding = TypeConverter.ToObject(Engine, thisArg); } else { thisBinding = thisArg; } var localEnv = LexicalEnvironment.NewDeclarativeEnvironment(Engine, Scope); Engine.EnterExecutionContext(localEnv, localEnv, thisBinding); try { Engine.DeclarationBindingInstantiation( DeclarationBindingType.FunctionCode, _functionDeclaration.FunctionDeclarations, _functionDeclaration.VariableDeclarations, this, arguments); var result = Engine.ExecuteStatement(_functionDeclaration.Body); if (result.Type == Completion.Throw) { JavaScriptException ex = new JavaScriptException(result.GetValueOrDefault()) .SetCallstack(Engine, result.Location); throw ex; } if (result.Type == Completion.Return) { scope.Teardown(); Engine.PoolStrictMode.Put(scope); return(result.GetValueOrDefault()); } } finally { Engine.LeaveExecutionContext(); } scope.Teardown(); Engine.PoolStrictMode.Put(scope); return(Undefined.Instance); } }
public void CallState(RuntimeState state) { CallArgs args = (CallArgs)state.arg; JsValue thisArg = args.thisObject; JsValue[] arguments = args.arguments; if (state.calleeReturned) { try { var result = (Completion)state.calleeReturnValue; var value = result.GetValueOrDefault(); var argumentInstanceRented = (bool)state.local; // we can safely release arguments if they don't escape the scope if (argumentInstanceRented && _engine.ExecutionContext.LexicalEnvironment?._record is DeclarativeEnvironmentRecord && !(result.Value is ArgumentsInstance)) { var der = _engine.ExecutionContext.LexicalEnvironment._record as DeclarativeEnvironmentRecord; der.ReleaseArguments(); } if (result.Type == CompletionType.Throw) { var ex = new JavaScriptException(value).SetCallstack(_engine, result.Location); throw ex; } if (result.Type == CompletionType.Return) { _engine.Return((JsValue)(value)); return; } } finally { _engine.LeaveExecutionContext(); } _engine.Return((JsValue)(Undefined)); return; } else { // setup new execution context http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.3 JsValue thisBinding; if (StrictModeScope.IsStrictModeCode) { thisBinding = thisArg; } else if (thisArg._type == Types.Undefined || thisArg._type == Types.Null) { thisBinding = _engine.Global; } else if (thisArg._type != Types.Object) { thisBinding = TypeConverter.ToObject(_engine, thisArg); } else { thisBinding = thisArg; } var localEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, _scope); _engine.EnterExecutionContext(localEnv, localEnv, thisBinding); state.local = _engine.DeclarationBindingInstantiation( DeclarationBindingType.FunctionCode, _functionDeclaration.HoistingScope.FunctionDeclarations, _functionDeclaration.HoistingScope.VariableDeclarations, this, arguments); _engine.Call(_engine.ExecuteStatement, _functionDeclaration.Body); return; } }