internal void OnStep(Statement statement) { var old = _stepMode; if (statement == null) { return; } BreakPoint breakpoint = _engine.BreakPoints.FirstOrDefault(breakPoint => BpTest(statement, breakPoint)); bool breakpointFound = false; if (breakpoint != null) { DebugInformation info = CreateDebugInformation(statement); var result = _engine.InvokeBreakEvent(info); if (result.HasValue) { _stepMode = result.Value; breakpointFound = true; } } if (breakpointFound == false && _stepMode == StepMode.Into) { DebugInformation info = CreateDebugInformation(statement); var result = _engine.InvokeStepEvent(info); if (result.HasValue) { _stepMode = result.Value; } } if (old == StepMode.Into && _stepMode == StepMode.Out) { _callBackStepOverDepth = _debugCallStack.Count; } else if (old == StepMode.Into && _stepMode == StepMode.Over) { var expressionStatement = statement as ExpressionStatement; if (expressionStatement != null && expressionStatement.Expression is CallExpression) { _callBackStepOverDepth = _debugCallStack.Count; } else { _stepMode = StepMode.Into; } } }
private Completion ExecuteStatement(Statement statement) { return _engine.ExecuteStatement(statement); }
public Completion ExecuteStatement(Statement statement) { var maxStatements = Options.GetMaxStatements(); if (maxStatements > 0 && _statementsCount++ > maxStatements) { throw new StatementsCountOverflowException(); } if (_timeoutTicks > 0 && _timeoutTicks < DateTime.UtcNow.Ticks) { throw new TimeoutException(); } _lastSyntaxNode = statement; if (Options.IsDebugMode()) { DebugHandler.OnStep(statement); } switch (statement.Type) { case SyntaxNodes.BlockStatement: return _statements.ExecuteBlockStatement(statement.As<BlockStatement>()); case SyntaxNodes.BreakStatement: return _statements.ExecuteBreakStatement(statement.As<BreakStatement>()); case SyntaxNodes.ContinueStatement: return _statements.ExecuteContinueStatement(statement.As<ContinueStatement>()); case SyntaxNodes.DoWhileStatement: return _statements.ExecuteDoWhileStatement(statement.As<DoWhileStatement>()); case SyntaxNodes.DebuggerStatement: return _statements.ExecuteDebuggerStatement(statement.As<DebuggerStatement>()); case SyntaxNodes.EmptyStatement: return _statements.ExecuteEmptyStatement(statement.As<EmptyStatement>()); case SyntaxNodes.ExpressionStatement: return _statements.ExecuteExpressionStatement(statement.As<ExpressionStatement>()); case SyntaxNodes.ForStatement: return _statements.ExecuteForStatement(statement.As<ForStatement>()); case SyntaxNodes.ForInStatement: return _statements.ExecuteForInStatement(statement.As<ForInStatement>()); case SyntaxNodes.FunctionDeclaration: return new Completion(Completion.Normal, null, null); case SyntaxNodes.IfStatement: return _statements.ExecuteIfStatement(statement.As<IfStatement>()); case SyntaxNodes.LabeledStatement: return _statements.ExecuteLabelledStatement(statement.As<LabelledStatement>()); case SyntaxNodes.ReturnStatement: return _statements.ExecuteReturnStatement(statement.As<ReturnStatement>()); case SyntaxNodes.SwitchStatement: return _statements.ExecuteSwitchStatement(statement.As<SwitchStatement>()); case SyntaxNodes.ThrowStatement: return _statements.ExecuteThrowStatement(statement.As<ThrowStatement>()); case SyntaxNodes.TryStatement: return _statements.ExecuteTryStatement(statement.As<TryStatement>()); case SyntaxNodes.VariableDeclaration: return _statements.ExecuteVariableDeclaration(statement.As<VariableDeclaration>()); case SyntaxNodes.WhileStatement: return _statements.ExecuteWhileStatement(statement.As<WhileStatement>()); case SyntaxNodes.WithStatement: return _statements.ExecuteWithStatement(statement.As<WithStatement>()); case SyntaxNodes.Program: return _statements.ExecuteProgram(statement.As<Program>()); default: throw new ArgumentOutOfRangeException(); } }
private void ProcessStatement(Statement statement, ParserContext context) { context = new ParserContext(context.Nodes); if (statement is FunctionDeclaration) { ProcessFunctionDeclaration(statement.As<FunctionDeclaration>(), context); return; } if (statement is VariableDeclaration) { ProcessVariableDeclaration(statement.As<VariableDeclaration>(), context); return; } if (statement is ExpressionStatement) { ProcessExpression(statement.As<ExpressionStatement>().Expression, context); return; } if (statement is ReturnStatement) { ProcessExpression(statement.As<ReturnStatement>().Argument, context); return; } if (statement is BlockStatement) { ProcessStatements(statement.As<BlockStatement>().Body, context); } if (statement is IfStatement) { ProcessExpression(statement.As<IfStatement>().Test, context); ProcessStatement(statement.As<IfStatement>().Consequent, context); ProcessStatement(statement.As<IfStatement>().Alternate, context); } if (statement is TryStatement) { ProcessStatement(statement.As<TryStatement>().Block, context); ProcessStatement(statement.As<TryStatement>().Finalizer, context); ProcessStatements(statement.As<TryStatement>().Handlers.OfType<Statement>(), context); ProcessStatements(statement.As<TryStatement>().GuardedHandlers, context); } if (statement is CatchClause) { ProcessStatement(statement.As<CatchClause>().Body, context); } if (statement is SwitchStatement) { ProcessExpression(statement.As<SwitchStatement>().Discriminant, context); ProcessStatements(statement.As<SwitchStatement>().Cases.SelectMany(c => c.Consequent), context); } }
private void VisitStatement(Statement statement, RequireCall parentCall, NodeWithChildren parentNode) { if (statement == null || this.ShouldSkipNode(statement)) { return; } var currentNode = new NodeWithChildren { Node = statement }; if (parentNode != null) { currentNode.Parent = parentNode; parentNode.Children.Add(currentNode); } else { visitedNodes.Add(currentNode); } switch (statement.Type) { case SyntaxNodes.BlockStatement: var block = statement.As<BlockStatement>(); VisitNodeEnumerator(block.Body, parentCall, currentNode); break; case SyntaxNodes.DoWhileStatement: var doWhile = statement.As<DoWhileStatement>(); VisitStatement(doWhile.Body, parentCall, currentNode); break; case SyntaxNodes.ExpressionStatement: var expression = statement.As<ExpressionStatement>(); VisitExpression(expression.Expression, parentCall, currentNode); break; case SyntaxNodes.ForInStatement: var forIn = statement.As<ForInStatement>(); VisitStatement(forIn.Body, parentCall, currentNode); break; case SyntaxNodes.ForStatement: var forStatement = statement.As<ForStatement>(); VisitStatement(forStatement.Body, parentCall, currentNode); break; case SyntaxNodes.FunctionDeclaration: var funcDeclaration = statement.As<FunctionDeclaration>(); VisitStatement(funcDeclaration.Body, parentCall, currentNode); break; case SyntaxNodes.IfStatement: var ifStatement = statement.As<IfStatement>(); VisitStatement(ifStatement.Alternate, parentCall, currentNode); VisitStatement(ifStatement.Consequent, parentCall, currentNode); break; case SyntaxNodes.ReturnStatement: var returnStatement = statement.As<ReturnStatement>(); VisitExpression(returnStatement.Argument, parentCall, currentNode); break; case SyntaxNodes.TryStatement: var tryStatement = statement.As<TryStatement>(); VisitStatement(tryStatement.Block, parentCall, currentNode); break; case SyntaxNodes.CatchClause: var catchClause = statement.As<CatchClause>(); VisitStatement(catchClause.Body, parentCall, currentNode); break; case SyntaxNodes.VariableDeclaration: var varDeclaration = statement.As<VariableDeclaration>(); VisitNodeEnumerator(varDeclaration.Declarations, parentCall, currentNode); break; case SyntaxNodes.WhileStatement: var whileStatement = statement.As<WhileStatement>(); VisitStatement(whileStatement.Body, parentCall, currentNode); break; case SyntaxNodes.WithStatement: var withStatement = statement.As<WithStatement>(); VisitStatement(withStatement.Body, parentCall, currentNode); break; default: break; } }
private DebugInformation CreateDebugInformation(Statement statement) { var info = new DebugInformation { CurrentStatement = statement, CallStack = _debugCallStack }; if (_engine.ExecutionContext != null && _engine.ExecutionContext.LexicalEnvironment != null) { var lexicalEnvironment = _engine.ExecutionContext.LexicalEnvironment; info.Locals = GetLocalVariables(lexicalEnvironment); info.Globals = GetGlobalVariables(lexicalEnvironment); } return info; }
private bool BpTest(Statement statement, BreakPoint breakpoint) { bool afterStart, beforeEnd; afterStart = (breakpoint.Line == statement.Location.Start.Line && breakpoint.Char >= statement.Location.Start.Column); if (!afterStart) { return false; } beforeEnd = breakpoint.Line < statement.Location.End.Line || (breakpoint.Line == statement.Location.End.Line && breakpoint.Char <= statement.Location.End.Column); if (!beforeEnd) { return false; } if (!string.IsNullOrEmpty(breakpoint.Condition)) { return _engine.Execute(breakpoint.Condition).GetCompletionValue().AsBoolean(); } return true; }