Program Listing for File VirtualCFGIterator.h

↰ Return to documentation for file (src/midend/programAnalysis/genericDataflow/cfgUtils/VirtualCFGIterator.h)

#include <featureTests.h>
#ifdef ROSE_ENABLE_SOURCE_ANALYSIS

#ifndef VIRTUAL_CFG_ITERATOR
#define VIRTUAL_CFG_ITERATOR

#include "virtualCFG.h"
#include "DataflowCFG.h"
//#include "baseCFGIterator.h"

#include <list>
#include <set>
#include <string>

namespace VirtualCFG{

// Iterates over DataflowNodes in a VirtualCFG, respecting dependences in the graph.
// Supports both forward and backward iteration.
class iterator/* : public virtual BaseCFG::iterator*/
{
        //protected:
        public:

        std::list<DataflowNode> remainingNodes;
        //map<DataflowNode, bool> visited;
        std::set<DataflowNode> visited;
        bool initialized;

        public:
        iterator();

        iterator(const DataflowNode &start);
        virtual ~iterator() { }

        void init(const DataflowNode &start);

        protected:
        // returns true if the given DataflowNode is in the remainingNodes list and false otherwise
        bool isRemaining(DataflowNode n);

        // advances this iterator in the given direction. Forwards if fwDir=true and backwards if fwDir=false.
        // if pushAllChildren=true, all of the current node's unvisited children (predecessors or successors,
        //    depending on fwDir) are pushed onto remainingNodes
        void advance(bool fwDir, bool pushAllChildren);

        public:
        virtual void operator ++ (int);

        bool eq(const iterator& other_it) const;

        bool operator==(const iterator& other_it) const;

        bool operator!=(const iterator& it) const;

        DataflowNode& operator * ();

        // Returns a fresh iterator that starts at node n
        static iterator begin(DataflowNode n);

        // Returns an empty iterator that can be compared to any other iterator to
        // check if it has completed passing over its iteration space
        static iterator end();

        // Contains the state of an iterator, allowing iterators to be
        // checkpointed and restarted.
        class checkpoint/* : public virtual BaseCFG::iterator::checkpoint*/
        {
          std::list<DataflowNode> remainingNodes;
          std::set<DataflowNode> visited;

                public:
          checkpoint(const std::list<DataflowNode>& remainingNodes, const std::set<DataflowNode>& visited);

                checkpoint(const checkpoint& that);

                std::string str(std::string indent="");

                friend class iterator;
        };

        // Returns a checkpoint of this iterator's progress.
        checkpoint getChkpt();

        // Loads this iterator's state from the given checkpoint.
        void restartFromChkpt(checkpoint& chkpt);

        std::string str(std::string indent="");
};

class back_iterator : /*public virtual BaseCFG::backiterator, */public virtual iterator
{
        public:
        back_iterator(): iterator() {}

        back_iterator(const DataflowNode &end): iterator(end) { }

        void operator ++ (int);
};

class dataflow : /*public virtual BaseCFG::dataflow, */public virtual iterator
{
        DataflowNode terminator;
        public:
        //dataflow(): iterator() {}

        dataflow(const DataflowNode &terminator_arg);

        //dataflow(const DataflowNode &start) : iterator(start) {}
        dataflow(const DataflowNode &start, const DataflowNode &terminator_arg);

        void init(const DataflowNode &start_arg, const DataflowNode &terminator_arg);

        // Initializes this iterator's terminator node
        /*void setTerminator(const DataflowNode &terminator) {
                initialized = true;
                this->terminator = terminator;
        }*/

        void add(const DataflowNode &next);

        //void operator ++ (int);

        // Contains the state of an dataflow iterator, allowing dataflow
        // iterators to be checkpointed and restarted.
        class checkpoint/* : public virtual BaseCFG::dataflow::checkpoint*/
        {
                iterator::checkpoint iChkpt;
                DataflowNode terminator;

                public:
                checkpoint(const iterator::checkpoint& iChkpt, const DataflowNode& terminator);

                checkpoint(const checkpoint &that);

                std::string str(std::string indent="");

                friend class dataflow;
        };

        // Returns a checkpoint of this dataflow iterator's progress.
        checkpoint getChkpt();

        // Loads this dataflow iterator's state from the given checkpoint.
        void restartFromChkpt(checkpoint& chkpt);

        std::string str(std::string indent="");
};

class back_dataflow: /*public virtual BaseCFG::back_dataflow,*/ public virtual dataflow
{
        public:
        //back_dataflow(): back_iterator() {}

        back_dataflow(const DataflowNode &terminator_arg) : dataflow(terminator_arg) {}

        //back_dataflow(const DataflowNode &end) : iterator(end) {}

        back_dataflow(const DataflowNode &end, const DataflowNode &terminator_arg);

        void operator ++ (int);
};
}
#endif
#endif