/// <summary>
/// Handles the given foreach statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleForeachStatement(ForEachStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Expression);
this.IsLoopHeadNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var foreachNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(foreachNode);
foreachNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
foreachNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this);
}
else
{
foreachNode.Construct(new SyntaxList <StatementSyntax> {
stmt.Statement
}, 0, false, this);
}
}
/// <summary>
/// Handles the given while statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleWhileStatement(WhileStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Condition);
this.IsLoopHeadNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var whileNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(whileNode);
whileNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
whileNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this);
}
else
{
whileNode.Construct(new SyntaxList <StatementSyntax> {
stmt.Statement
}, 0, false, this);
}
}
/// <summary>
/// Handles the given if statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleIfStatement(IfStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Condition);
this.IsJumpNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var ifNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(ifNode);
ifNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
ifNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
ifNode.Construct(new SyntaxList <StatementSyntax> {
stmt.Statement
}, 0, false, successor);
}
if (stmt.Else != null)
{
var elseNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(elseNode);
elseNode.IPredecessors.Add(this);
if (stmt.Else.Statement is IfStatementSyntax)
{
elseNode.HandleIfStatement(stmt.Else.Statement as IfStatementSyntax, successor);
}
else
{
if (stmt.Else.Statement is BlockSyntax)
{
elseNode.Construct((stmt.Else.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
elseNode.Construct(new SyntaxList <StatementSyntax> {
stmt.Else.Statement
}, 0, false, successor);
}
}
}
}
/// <summary>
/// Handles the given try statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleTryStatement(TryStatementSyntax stmt, ControlFlowGraphNode successor)
{
if (Configuration.AnalyzeExceptionHandling)
{
var catchSuccessors = new List <ControlFlowGraphNode>();
foreach (var catchBlock in stmt.Catches)
{
var catchSucc = new ControlFlowGraphNode(this.Summary);
catchSucc.Construct(catchBlock.Block.Statements, 0, false, successor);
catchSuccessors.Add(catchSucc);
}
ControlFlowGraphNode pred = null;
for (int idx = 0; idx < stmt.Block.Statements.Count; idx++)
{
var tryNode = new ControlFlowGraphNode(this.Summary);
tryNode.IsJumpNode = true;
if (idx == 0)
{
tryNode = this;
}
if (idx + 1 == stmt.Block.Statements.Count)
{
tryNode.Construct(stmt.Block.Statements, idx, true, successor);
}
else
{
tryNode.Construct(stmt.Block.Statements, idx, true, null);
}
foreach (var catchNode in catchSuccessors)
{
tryNode.ISuccessors.Add(catchNode);
catchNode.IPredecessors.Add(tryNode);
}
if (pred != null)
{
pred.ISuccessors.Add(tryNode);
tryNode.IPredecessors.Add(pred);
}
pred = tryNode;
}
}
else
{
this.Construct(stmt.Block.Statements, 0, false, successor);
}
}
/// <summary>
/// Handles the given using statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleUsingStatement(UsingStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Declaration);
this.IsJumpNode = true;
var usingNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(usingNode);
usingNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
usingNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
usingNode.Construct(new SyntaxList <StatementSyntax> {
stmt.Statement
}, 0, false, successor);
}
}
/// <summary>
/// Handles the given switch statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleSwitchStatement(SwitchStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Expression);
this.IsJumpNode = true;
if (stmt.Sections.Count == 0 &&
successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
return;
}
for (int idx = 0; idx < stmt.Sections.Count; idx++)
{
var statements = stmt.Sections[idx].Statements;
bool containsBreak = false;
foreach (var s in statements)
{
if (s is BreakStatementSyntax)
{
containsBreak = true;
break;
}
}
var switchNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(switchNode);
switchNode.IPredecessors.Add(this);
if (containsBreak || idx == stmt.Sections.Count - 1)
{
switchNode.Construct(statements, 0, false, successor);
}
else
{
switchNode.Construct(statements, 0, false, null);
}
}
}
/// <summary>
/// Handles the given while statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleWhileStatement(WhileStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Condition);
this.IsLoopHeadNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var whileNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(whileNode);
whileNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
whileNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this);
}
else
{
whileNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, this);
}
}
/// <summary>
/// Handles the given using statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleUsingStatement(UsingStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Declaration);
this.IsJumpNode = true;
var usingNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(usingNode);
usingNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
usingNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
usingNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, successor);
}
}
/// <summary>
/// Handles the given try statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleTryStatement(TryStatementSyntax stmt, ControlFlowGraphNode successor)
{
if (Configuration.AnalyzeExceptionHandling)
{
var catchSuccessors = new List<ControlFlowGraphNode>();
foreach (var catchBlock in stmt.Catches)
{
var catchSucc = new ControlFlowGraphNode(this.Summary);
catchSucc.Construct(catchBlock.Block.Statements, 0, false, successor);
catchSuccessors.Add(catchSucc);
}
ControlFlowGraphNode pred = null;
for (int idx = 0; idx < stmt.Block.Statements.Count; idx++)
{
var tryNode = new ControlFlowGraphNode(this.Summary);
tryNode.IsJumpNode = true;
if (idx == 0)
{
tryNode = this;
}
if (idx + 1 == stmt.Block.Statements.Count)
{
tryNode.Construct(stmt.Block.Statements, idx, true, successor);
}
else
{
tryNode.Construct(stmt.Block.Statements, idx, true, null);
}
foreach (var catchNode in catchSuccessors)
{
tryNode.ISuccessors.Add(catchNode);
catchNode.IPredecessors.Add(tryNode);
}
if (pred != null)
{
pred.ISuccessors.Add(tryNode);
tryNode.IPredecessors.Add(pred);
}
pred = tryNode;
}
}
else
{
this.Construct(stmt.Block.Statements, 0, false, successor);
}
}
/// <summary>
/// Handles the given switch statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleSwitchStatement(SwitchStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Expression);
this.IsJumpNode = true;
if (stmt.Sections.Count == 0 &&
successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
return;
}
for (int idx = 0; idx < stmt.Sections.Count; idx++)
{
var statements = stmt.Sections[idx].Statements;
bool containsBreak = false;
foreach (var s in statements)
{
if (s is BreakStatementSyntax)
{
containsBreak = true;
break;
}
}
var switchNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(switchNode);
switchNode.IPredecessors.Add(this);
if (containsBreak || idx == stmt.Sections.Count - 1)
{
switchNode.Construct(statements, 0, false, successor);
}
else
{
switchNode.Construct(statements, 0, false, null);
}
}
}
/// <summary>
/// Handles the given if statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleIfStatement(IfStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Condition);
this.IsJumpNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var ifNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(ifNode);
ifNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
ifNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
ifNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, successor);
}
if (stmt.Else != null)
{
var elseNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(elseNode);
elseNode.IPredecessors.Add(this);
if (stmt.Else.Statement is IfStatementSyntax)
{
elseNode.HandleIfStatement(stmt.Else.Statement as IfStatementSyntax, successor);
}
else
{
if (stmt.Else.Statement is BlockSyntax)
{
elseNode.Construct((stmt.Else.Statement as BlockSyntax).Statements, 0, false, successor);
}
else
{
elseNode.Construct(new SyntaxList<StatementSyntax> { stmt.Else.Statement }, 0, false, successor);
}
}
}
}
/// <summary>
/// Handles the given foreach statement.
/// </summary>
/// <param name="stmt">Statement</param>
/// <param name="successor">Successor</param>
private void HandleForeachStatement(ForEachStatementSyntax stmt, ControlFlowGraphNode successor)
{
this.SyntaxNodes.Add(stmt.Expression);
this.IsLoopHeadNode = true;
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
this.LoopExitNode = successor;
}
var foreachNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(foreachNode);
foreachNode.IPredecessors.Add(this);
if (stmt.Statement is BlockSyntax)
{
foreachNode.Construct((stmt.Statement as BlockSyntax).Statements, 0, false, this);
}
else
{
foreachNode.Construct(new SyntaxList<StatementSyntax> { stmt.Statement }, 0, false, this);
}
}
/// <summary>
/// Constructs the node from the given list of statements starting
/// at the given index.
/// </summary>
/// <param name="stmtList">List of statements</param>
/// <param name="index">Index</param>
/// <param name="isBound">Processes only one statement</param>
/// <param name="successor">Successor</param>
internal void Construct(SyntaxList<StatementSyntax> stmtList, int index, bool isBound,
ControlFlowGraphNode successor)
{
int boundary = stmtList.Count;
if (isBound && index == stmtList.Count)
{
boundary = stmtList.Count;
}
else if (isBound)
{
boundary = index + 1;
}
for (int idx = index; idx < boundary; idx++)
{
ControlFlowGraphNode givesUpNode = null;
ControlFlowGraphNode jumpNode = null;
ControlFlowGraphNode succNode = null;
if (stmtList[idx] is ExpressionStatementSyntax ||
stmtList[idx] is LocalDeclarationStatementSyntax)
{
var invocations = stmtList[idx].DescendantNodesAndSelf().
OfType<InvocationExpressionSyntax>();
if (invocations.Count() > 0)
{
var call = invocations.First();
if (this.IsGivesUpOperation(call))
{
if (this.SyntaxNodes.Count == 0)
{
givesUpNode = this;
}
else
{
givesUpNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(givesUpNode);
givesUpNode.IPredecessors.Add(this);
}
givesUpNode.IsGivesUpNode = true;
this.Summary.GivesUpNodes.Add(givesUpNode);
givesUpNode.SyntaxNodes.Add(stmtList[idx]);
if (idx < boundary - 1 &&
stmtList[idx + 1] is BreakStatementSyntax)
{
if (successor != null &&
successor.LoopExitNode != null)
{
givesUpNode.ISuccessors.Add(successor.LoopExitNode);
successor.LoopExitNode.IPredecessors.Add(givesUpNode);
}
}
else if (idx < boundary - 1 &&
stmtList[idx + 1] is ContinueStatementSyntax)
{
if (successor != null)
{
givesUpNode.ISuccessors.Add(successor);
successor.IPredecessors.Add(givesUpNode);
}
}
else if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
givesUpNode.ISuccessors.Add(succNode);
succNode.IPredecessors.Add(givesUpNode);
succNode.Construct(stmtList, idx + 1, false, successor);
}
else if (successor != null)
{
givesUpNode.ISuccessors.Add(successor);
successor.IPredecessors.Add(givesUpNode);
}
return;
}
}
this.SyntaxNodes.Add(stmtList[idx]);
continue;
}
else if (stmtList[idx] is BreakStatementSyntax)
{
if (successor != null && successor.LoopExitNode != null)
{
this.ISuccessors.Add(successor.LoopExitNode);
successor.LoopExitNode.IPredecessors.Add(this);
}
return;
}
else if (stmtList[idx] is ContinueStatementSyntax)
{
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
}
return;
}
else if (stmtList[idx] is ReturnStatementSyntax)
{
this.SyntaxNodes.Add(stmtList[idx]);
continue;
}
if (this.SyntaxNodes.Count == 0)
{
jumpNode = this;
}
else
{
jumpNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(jumpNode);
jumpNode.IPredecessors.Add(this);
}
if (stmtList[idx] is IfStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleIfStatement(stmtList[idx] as IfStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleIfStatement(stmtList[idx] as IfStatementSyntax, successor);
}
}
else if (stmtList[idx] is ForStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleForStatement(stmtList[idx] as ForStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleForStatement(stmtList[idx] as ForStatementSyntax, successor);
}
}
else if (stmtList[idx] is WhileStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleWhileStatement(stmtList[idx] as WhileStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleWhileStatement(stmtList[idx] as WhileStatementSyntax, successor);
}
}
else if (stmtList[idx] is DoStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleDoStatement(stmtList[idx] as DoStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleDoStatement(stmtList[idx] as DoStatementSyntax, successor);
}
}
else if (stmtList[idx] is ForEachStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleForeachStatement(stmtList[idx] as ForEachStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleForeachStatement(stmtList[idx] as ForEachStatementSyntax, successor);
}
}
else if (stmtList[idx] is SwitchStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleSwitchStatement(stmtList[idx] as SwitchStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleSwitchStatement(stmtList[idx] as SwitchStatementSyntax, successor);
}
}
else if (stmtList[idx] is TryStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleTryStatement(stmtList[idx] as TryStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleTryStatement(stmtList[idx] as TryStatementSyntax, successor);
}
}
else if (stmtList[idx] is UsingStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleUsingStatement(stmtList[idx] as UsingStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleUsingStatement(stmtList[idx] as UsingStatementSyntax, successor);
}
}
}
if (successor != null && (this.IsJumpNode ||
(!this.IsJumpNode && this.ISuccessors.Count == 0)))
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
}
if (this.SyntaxNodes.Count == 0)
{
foreach (var pred in this.IPredecessors)
{
pred.ISuccessors.Remove(this);
}
}
}
/// <summary>
/// Constructs the node from the given list of statements starting
/// at the given index.
/// </summary>
/// <param name="stmtList">List of statements</param>
/// <param name="index">Index</param>
/// <param name="isBound">Processes only one statement</param>
/// <param name="successor">Successor</param>
internal void Construct(SyntaxList <StatementSyntax> stmtList, int index, bool isBound,
ControlFlowGraphNode successor)
{
int boundary = stmtList.Count;
if (isBound && index == stmtList.Count)
{
boundary = stmtList.Count;
}
else if (isBound)
{
boundary = index + 1;
}
for (int idx = index; idx < boundary; idx++)
{
ControlFlowGraphNode givesUpNode = null;
ControlFlowGraphNode jumpNode = null;
ControlFlowGraphNode succNode = null;
if (stmtList[idx] is ExpressionStatementSyntax ||
stmtList[idx] is LocalDeclarationStatementSyntax)
{
var invocations = stmtList[idx].DescendantNodesAndSelf().
OfType <InvocationExpressionSyntax>();
if (invocations.Count() > 0)
{
var call = invocations.First();
if (this.IsGivesUpOperation(call))
{
if (this.SyntaxNodes.Count == 0)
{
givesUpNode = this;
}
else
{
givesUpNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(givesUpNode);
givesUpNode.IPredecessors.Add(this);
}
givesUpNode.IsGivesUpNode = true;
this.Summary.GivesUpNodes.Add(givesUpNode);
givesUpNode.SyntaxNodes.Add(stmtList[idx]);
if (idx < boundary - 1 &&
stmtList[idx + 1] is BreakStatementSyntax)
{
if (successor != null &&
successor.LoopExitNode != null)
{
givesUpNode.ISuccessors.Add(successor.LoopExitNode);
successor.LoopExitNode.IPredecessors.Add(givesUpNode);
}
}
else if (idx < boundary - 1 &&
stmtList[idx + 1] is ContinueStatementSyntax)
{
if (successor != null)
{
givesUpNode.ISuccessors.Add(successor);
successor.IPredecessors.Add(givesUpNode);
}
}
else if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
givesUpNode.ISuccessors.Add(succNode);
succNode.IPredecessors.Add(givesUpNode);
succNode.Construct(stmtList, idx + 1, false, successor);
}
else if (successor != null)
{
givesUpNode.ISuccessors.Add(successor);
successor.IPredecessors.Add(givesUpNode);
}
return;
}
}
this.SyntaxNodes.Add(stmtList[idx]);
continue;
}
else if (stmtList[idx] is BreakStatementSyntax)
{
if (successor != null && successor.LoopExitNode != null)
{
this.ISuccessors.Add(successor.LoopExitNode);
successor.LoopExitNode.IPredecessors.Add(this);
}
return;
}
else if (stmtList[idx] is ContinueStatementSyntax)
{
if (successor != null)
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
}
return;
}
else if (stmtList[idx] is ReturnStatementSyntax)
{
this.SyntaxNodes.Add(stmtList[idx]);
continue;
}
if (this.SyntaxNodes.Count == 0)
{
jumpNode = this;
}
else
{
jumpNode = new ControlFlowGraphNode(this.Summary);
this.ISuccessors.Add(jumpNode);
jumpNode.IPredecessors.Add(this);
}
if (stmtList[idx] is IfStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleIfStatement(stmtList[idx] as IfStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleIfStatement(stmtList[idx] as IfStatementSyntax, successor);
}
}
else if (stmtList[idx] is ForStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleForStatement(stmtList[idx] as ForStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleForStatement(stmtList[idx] as ForStatementSyntax, successor);
}
}
else if (stmtList[idx] is WhileStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleWhileStatement(stmtList[idx] as WhileStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleWhileStatement(stmtList[idx] as WhileStatementSyntax, successor);
}
}
else if (stmtList[idx] is DoStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleDoStatement(stmtList[idx] as DoStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleDoStatement(stmtList[idx] as DoStatementSyntax, successor);
}
}
else if (stmtList[idx] is ForEachStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleForeachStatement(stmtList[idx] as ForEachStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleForeachStatement(stmtList[idx] as ForEachStatementSyntax, successor);
}
}
else if (stmtList[idx] is SwitchStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleSwitchStatement(stmtList[idx] as SwitchStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleSwitchStatement(stmtList[idx] as SwitchStatementSyntax, successor);
}
}
else if (stmtList[idx] is TryStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleTryStatement(stmtList[idx] as TryStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleTryStatement(stmtList[idx] as TryStatementSyntax, successor);
}
}
else if (stmtList[idx] is UsingStatementSyntax)
{
if (idx < boundary - 1)
{
succNode = new ControlFlowGraphNode(this.Summary);
jumpNode.HandleUsingStatement(stmtList[idx] as UsingStatementSyntax, succNode);
succNode.Construct(stmtList, idx + 1, false, successor);
return;
}
else
{
jumpNode.HandleUsingStatement(stmtList[idx] as UsingStatementSyntax, successor);
}
}
}
if (successor != null && (this.IsJumpNode ||
(!this.IsJumpNode && this.ISuccessors.Count == 0)))
{
this.ISuccessors.Add(successor);
successor.IPredecessors.Add(this);
}
if (this.SyntaxNodes.Count == 0)
{
foreach (var pred in this.IPredecessors)
{
pred.ISuccessors.Remove(this);
}
}
}
