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