sageCopy.h

#ifndef ROSE_sageCopy_H
#define ROSE_sageCopy_H
 
#include <map>
#include <vector>
 
class SgCopyHelp
   {
     public:
      // STL map type
         typedef std::map<const SgNode*,SgNode*> copiedNodeMapType;
 
     private:
      // DQ (10/8/2007): Added support for the depth to be kept track of in the AST copy mechansim.
         int depth;
 
      // This is mostly used for SgSymbol IR nodes (but will likely be used for other IR nodes in the future.
         copiedNodeMapType copiedNodeMap;
 
     public:
 
      // STL map iterator type
         typedef copiedNodeMapType::iterator copiedNodeMapTypeIterator;
 
          virtual SgNode *copyAst( const SgNode *n ) = 0;
 
       // Default constructor (required to initialize the depth
          SgCopyHelp() : depth(0) {}
 
       // Defined the virtual destructor
          virtual ~SgCopyHelp() {}
 
       // DQ (10/8/2007): Access functions for the depth (inlined for performance).
          int get_depth() { return depth; }
          void incrementDepth() { depth++; }
          void decrementDepth() { depth--; }
          copiedNodeMapType & get_copiedNodeMap() { return copiedNodeMap; }
 
       // Reset the state saved
          void clearState() { depth = 0; copiedNodeMap.clear(); }
 
       // Added things that generate symbols to the state (could be SgDeclarationStatement or SgInitializedName objects).
          void insertCopiedNodePair( const SgNode* key, SgNode* value );
 
   };
 
 
class SgShallowCopy : public SgCopyHelp
   {
     public:
          SgNode *copyAst( const SgNode *n ) { return const_cast<SgNode *>(n); }
   };
 
 
class ROSE_DLL_API SgTreeCopy : public SgCopyHelp
   {
     public:
          SgNode *copyAst( const SgNode *n );
   };
 
// PC (8/3/2006): Support for subnode capturing
template <class CopyType>
class SgCapturingCopy : public CopyType
   {
     protected:
          std::vector<SgNode *> origList;
          std::vector<SgNode *> copyList;
     public:
          SgCapturingCopy( std::vector<SgNode *> origList, const CopyType &base = CopyType() )
          // : origList(origList), CopyType(base)
             :  CopyType(base), origList(origList), copyList(origList.size())
             { }
          virtual ~SgCapturingCopy() { }
          SgNode *copyAst( const SgNode *n )
             {
               SgNode *newNode = CopyType::copyAst(n);
               int listSize = origList.size();
               for (int i = 0; i < listSize; i++)
                  {
                    if (origList[i] == n)
                       {
                         copyList[i] = newNode;
                       }
                  }
               return newNode;
             }
          const std::vector<SgNode *> &get_copyList()
             {
               return copyList;
             }
   };
 
#endif