Esempio n. 1
0
        public virtual void ReplaceStatement(Statement oldstat, Statement newstat)
        {
            foreach (StatEdge edge in oldstat.GetAllPredecessorEdges())
            {
                oldstat.RemovePredecessor(edge);
                edge.GetSource().ChangeEdgeNode(Direction_Forward, edge, newstat);
                newstat.AddPredecessor(edge);
            }
            foreach (StatEdge edge in oldstat.GetAllSuccessorEdges())
            {
                oldstat.RemoveSuccessor(edge);
                edge.SetSource(newstat);
                newstat.AddSuccessor(edge);
            }
            int statindex = stats.GetIndexByKey(oldstat.id);

            stats.RemoveWithKey(oldstat.id);
            stats.AddWithKeyAndIndex(statindex, newstat, newstat.id);
            newstat.SetParent(this);
            newstat.post = oldstat.post;
            if (first == oldstat)
            {
                first = newstat;
            }
            List <StatEdge> lst = new List <StatEdge>(oldstat.GetLabelEdges());

            for (int i = lst.Count - 1; i >= 0; i--)
            {
                StatEdge edge = lst[i];
                if (edge.GetSource() != newstat)
                {
                    newstat.AddLabeledEdge(edge);
                }
                else if (this == edge.GetDestination() || this.ContainsStatementStrict(edge.GetDestination
                                                                                           ()))
                {
                    edge.closure = null;
                }
                else
                {
                    this.AddLabeledEdge(edge);
                }
            }
            oldstat.GetLabelEdges().Clear();
        }
Esempio n. 2
0
        // *****************************************************************************
        // private methods
        // *****************************************************************************
        private static void AddToReversePostOrderListIterative(Statement root, IList
                                                               <Statement> lst)
        {
            LinkedList <Statement> stackNode  = new LinkedList <Statement>();
            LinkedList <int>       stackIndex = new LinkedList <int>();
            HashSet <Statement>    setVisited = new HashSet <Statement>();

            stackNode.AddLast(root);
            stackIndex.AddLast(0);
            while (!(stackNode.Count == 0))
            {
                Statement node  = stackNode.Last.Value;
                int       index = Sharpen.Collections.RemoveLast(stackIndex);
                setVisited.Add(node);
                List <StatEdge> lstEdges = node.GetAllSuccessorEdges();
                for (; index < lstEdges.Count; index++)
                {
                    StatEdge  edge = lstEdges[index];
                    Statement succ = edge.GetDestination();
                    if (!setVisited.Contains(succ) && (edge.GetType() == StatEdge.Type_Regular || edge
                                                       .GetType() == StatEdge.Type_Exception))
                    {
                        // TODO: edge filter?
                        stackIndex.AddLast(index + 1);
                        stackNode.AddLast(succ);
                        stackIndex.AddLast(0);
                        break;
                    }
                }
                if (index == lstEdges.Count)
                {
                    lst.Insert(0, node);
                    Sharpen.Collections.RemoveLast(stackNode);
                }
            }
        }