C# ControlFlowGraphNode.Construct方法代码示例

        /// <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 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 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;
//.........这里部分代码省略.........