SgNode.h

 
#ifndef ROSE_SgNode_H
#define ROSE_SgNode_H
#include <RoseFirst.h>
#include <Cxx_GrammarDeclarations.h>
 
 
 
/* #line 1 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
// WARNING -- GENERATED CODE -- DO NOT MODIFY THIS CODE -- WARNING!
//      This code is automatically generated for each 
//      terminal and non-terminal within the defined 
//      grammar.  There is a simple way to change the 
//      code to fix bugs etc.  See the ROSE README file
//      for directions.
 
// tps: (02/22/2010): Adding DLL export requirements
#include "rosedll.h"
 
// predeclarations for SgNode
 
/* #line 24 "../../../src/frontend/SageIII//SgNode.h" */
/* #line 2 "/workspace/src/ROSETTA/Grammar/Node.code" */
 
 
#include <ROSE_DEPRECATED.h>
#include <semaphore.h>
#include <rosePublicConfig.h>
#include "setup.h"
#include "Map.h"
#include <boost/format.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/version.hpp>
#endif
 
#include <Sawyer/CommandLine.h>
#include <Sawyer/Interval.h>
#include <Sawyer/IntervalSet.h>
 
#include "processSupport.h"
#define __builtin_constant_p(exp) (0)
 
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/AddressSet.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <Rose/BinaryAnalysis/AddressInterval.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <rose_extent.h>                                // deprecated
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Rose/BinaryAnalysis/InstructionMap.h>
#include <ROSE_NELMTS.h>
#endif
 
#include <Rose/Constants.h>
#include <sageHash.h>
#include <sageTraversal.h>
#include <sageRti.h>
#include <sageCopy.h>
#include <sageMemory.h>
#include <Cxx_GrammarVariants.h>
#include <Cxx_GrammarStorageClasses.h>
#include <virtualCFG.h>
 
namespace Rose { namespace Traits { namespace generated { template <typename NodeT> struct describe_node_t; } } }
namespace Rose { namespace Traits { namespace generated { template <typename NodeT, typename FieldT, FieldT NodeT::* fld_ptr> struct describe_field_t; } } }
 
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
// Version numbers for SgAsm* nodes. Used for backward compatibility. */
BOOST_CLASS_VERSION(SgAsmInstruction, 1);
#endif
 
class PreprocessingInfo;
class AstRegExAttribute;
class AstAttribute;
class AstAttributeMechanism;
struct ReferenceToPointerHandler;
 
// DQ (3/18/2006): Forward declarations of classes used to control and tailor the code generation.
class UnparseDelegate;
class UnparseFormatHelp;
 
// DQ (4/32/2006): g++ 4.0.2 requires a forward declaration for this (a friend class declaration is not sufficient!)
class AstSpecificDataManagingClassStorageClass;
 
 
 
/* #line 13 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $PREDECLARATIONS" */
 
/* #line 14 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
#if 1
// Class Definition for SgNode
class ROSE_DLL_API SgNode  
   {
     public:
 
 
/* #line 106 "../../../src/frontend/SageIII//SgNode.h" */
 
          virtual SgNode* copy ( SgCopyHelp& help) const;
// Start of memberFunctionString
/* #line 1 "/workspace/src/ROSETTA/Grammar/Common.code" */
 
// *** COMMON CODE SECTION BEGINS HERE ***
 
    public:
 
       // DQ (3/25/3006): I put this back in because it had the logic for where the copy function required 
       // and not required which is required to match the other aspects of the copy mechanism code generation.
       // Specifically it is a problem to declare the copy function everywhere because it is not implemented 
       // for the SgSymbol IR nodes. I'm not clear why it is not implemented for these IR nodes.
       /* \brief Copies AST (whole subtree, depending on the SgCopyHelp class */
       // virtual SgNode* copy ( const SgCopyHelp & help) const;
 
          virtual std::string class_name() const;
 
          virtual VariantT variantT() const; // MS: new variant used in tree traversal
 
       // King84 (2010.08.16): Moved this to an enum to save space, since it's only used at compiler-time anyway.
       // static const VariantT static_variant = V_SgNode;
          enum { static_variant = V_SgNode };
 
       /* the generated cast function */
          ROSE_DLL_API friend       SgNode* isSgNode(       SgNode * s );
 
          ROSE_DLL_API friend const SgNode* isSgNode( const SgNode * s );
 
     // ******************************************
     // * Memory Pool / New / Delete
     // ******************************************
 
     public:
          static const unsigned pool_size; // 
          static std::vector<unsigned char *> pools; // 
          static SgNode * next_node; // 
 
          static unsigned long initializeStorageClassArray(SgNodeStorageClass *); // 
 
          static void clearMemoryPool(); // 
          static void deleteMemoryPool(); // 
 
          static void extendMemoryPoolForFileIO(); // 
 
          static SgNode * getPointerFromGlobalIndex(unsigned long); // 
          static SgNode * getPointerFromGlobalIndex(AstSpecificDataManagingClass *, unsigned long); // 
 
          static unsigned long getNumberOfValidNodesAndSetGlobalIndexInFreepointer(unsigned long); // 
          static void resetValidFreepointers(); // 
          static unsigned long getNumberOfLastValidPointer(); // 
 
 
#if defined(INLINE_FUNCTIONS)
          inline void *operator new (size_t size);
#else
          void *operator new (size_t size);
#endif
          void operator delete (void* pointer, size_t size);
 
       // DQ (4/5/2007): This is not the correct operator that we want, but appears to be required to compile ROSE with ROSE.
          void operator delete (void* pointer)
             {
            // This is the generated delete operator...
               SgNode::operator delete (pointer,sizeof(SgNode));
             }
 
          static size_t numberOfNodes();
 
          static size_t memoryUsage();
 
      // End of scope which started in IR nodes specific code 
      /* */
 
      /* name Internal Functions
          \brief Internal functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgeable users for specialized tools or applications.
 
          \internal We could not make these private because they are required by user for special purposes. And 
              it would be unwieldy to have many of the internal classes in ROSE be explicitly defined as friends.
         
       */
 
       // MS: 02/12/02 container of pointers to AST successor nodes used in the traversal
       // overridden in every class by *generated* implementation
          virtual std::vector<SgNode*> get_traversalSuccessorContainer() const;
       // MS: 06/28/02 container of names of variables or container indices 
       // used used in the traversal to access AST successor nodes
       // overridden in every class by *generated* implementation
          virtual std::vector<std::string> get_traversalSuccessorNamesContainer() const;
 
       // GB (09/25/2007): Functions for index-based access to traversal successors; these are hopefully a lot faster
       // than all the vector copies. The implementation for these functions is generated for each class.
          virtual size_t get_numberOfTraversalSuccessors() const;
          virtual SgNode *get_traversalSuccessorByIndex(size_t idx) const;
          virtual size_t get_childIndex(SgNode *child) const;
 
#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
       // MS: 08/16/2002 method for generating RTI information
          virtual RTIReturnType roseRTI();
#endif
      /* */
 
 
 
      /* name Deprecated Functions
          \brief Deprecated functions ... incomplete-documentation
 
          These functions have been deprecated from use.
       */
      /* */
 
          virtual const char* sage_class_name() const  ROSE_DEPRECATED_FUNCTION;
 
      // JJW (10/16/2008): Changed to a single function in Node.code, and put
      // getVariant() in #if 0 block to prevent confusing Doxygen
#if 0
          virtual int variant() const ROSE_DEPRECATED_FUNCTION;
       // virtual int getVariant() const ROSE_DEPRECATED_FUNCTION;
#endif
      /* */
 
 
 
 
     public:
      /* name Traversal Support Functions
          \brief Traversal support functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgable users for specialized tools or applications.
       */
      /* */
 
       // DQ (11/26/2005): Support for visitor pattern mechanims
       // (inferior to ROSE traversal mechanism, experimental).
          void executeVisitorMemberFunction (ROSE_VisitorPattern & visitor);
 
      /* DXN (08/09/2010): support for the classic visitor pattern done in GoF */
          virtual void accept (ROSE_VisitorPattern & visitor);
 
       // DQ (12/26/2005): Support for traversal based on the memory pool
          static void traverseMemoryPoolNodes(ROSE_VisitTraversal & visit);
 
          static void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern & visitor);
 
       // DQ (2/9/2006): Added to support traversal over single representative of each IR node
       // This traversal helps support internal tools that call static member functions.
       // note: this function operates on the memory pools.
          static void visitRepresentativeNode (ROSE_VisitTraversal & visit);
      /* */
 
     public: 
        /* NodeId support functions */
        static SgNode* getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx);
        static SgNode* getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx);
        static std::string getNodeIdString(SgNode* sgnode);
        static std::string getNodeIdStringInternal(SgNode* sgnode);
 
     public:
      /* name Memory Allocation Functions
          \brief Memory allocations functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgable users for specialized tools or applications.
       */
      /* */
 
          virtual bool isInMemoryPool();
 
          virtual void checkDataMemberPointersIfInMemoryPool();
 
      // DQ (4/30/2006): Modified to be a const function.
          virtual std::vector<std::pair<SgNode*,std::string> > returnDataMemberPointers() const;
 
          virtual void processDataMemberReferenceToPointers(ReferenceToPointerHandler*);
 
          virtual long getChildIndex( SgNode* childNode ) const;
 
      // DQ (9/2/2015): Since this function is generated by ROSETTA, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Constructor for use by AST File I/O Mechanism
 
          This constructor permits the IR node to be rebuilt from the contiguously arranged data in memory 
          which obtained via fast binary file I/O from disk.
       */
       // SgNode( SgNodeStorageClass& source );
 
 
 
 
 
 // JH (10/24/2005): methods added to support the ast file IO
    private:
 
      /* name AST Memory Allocation Support Functions
          \brief Memory allocations support....
 
          These functions handle the low leve support of the memory allocation scheme which permits IR nodes to be allocated 
          in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
          and support the AST File I/O Mechanism.
       */
      /* */
 
       /* JH (10/24/2005): Two typedefs. The TestType notes the type every pointer is cast to before
          we compare them. Since I had several problems with this, I decided to make a typdef to ensure
          that I use the same type everywhere, if any changes are made. THe second one declares the type
          (actually unsigned long) where teh pointer address gets converted to. On 64 bit platforms this
          might got changed, but unfortunatly, the return types are still unsigned longs. There exists
          a correspinding one in the AST_FILE_IO class!
       */
      // DQ (9/2/2015): This typedef is no longer used, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Typedef used for low level memory access.
       */
       // typedef unsigned char* TestType;
 
      // DQ (9/2/2015): This typedef is no longer used, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Typedef used to hold memory addresses as values.
       */
       // typedef unsigned long  AddressType;
 
 
 
       // necessary, to have direct access to the p_freepointer and the private methods !
          friend class AST_FILE_IO;
 
          friend class SgNodeStorageClass;
 
          friend class AstSpecificDataManagingClass;
 
          friend class AstSpecificDataManagingClassStorageClass;
    public:
          SgNode( const SgNodeStorageClass& source );
 
 // private: // JJW hack
       /*
          name AST Memory Allocation Support Variables
          Memory allocations support variables 
 
          These variables handle the low level support of the memory allocation scheme which permits IR nodes to be allocated 
          in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
          and support the AST File I/O Mechanism.
       */
      /* */
 
    public:
 
      // DQ (11/21/2009): Added function to add new Regular Expression attributes and return pointer 
      // to current node (so that it will work cleanly with build functions to specify patterns).
      // virtual SgNode* addRegExpAttribute();
          SgNode* addRegExpAttribute(std::string s, AstRegExAttribute* a);
 
#ifndef _MSC_VER
// Rasmussen (04/17/2019): Support for ATerms has been deprecated as it is no longer needed
// and likely never fully implemented nor tested.  Files remain in the src tree but are no
// longer built.
#define BUILD_ATERM_SUPPORT 0
   #if BUILD_ATERM_SUPPORT
   #ifdef ROSE_USE_ROSE_ATERM_SUPPORT
      // DQ (10/4/2014): Adding ATerm support to ROSE.
       // Rasmussen (1/7/2019): Added to kill warning messages of overridden virtual function
          virtual ATerm generate_ATerm();
 
          virtual void generate_ATerm_Annotation(ATerm & term);
   #endif
   #endif // BUILD_ATERM_SUPPORT
#endif
       // These can't be virtual functions since we don't yet know what IR node to build (until we have read the aterm).
       // virtual generate_AST(ATerm & term);
       // virtual void read_ATerm_Annotation(ATerm & term);
 
// *** COMMON CODE SECTION ENDS HERE ***
 
 
// End of memberFunctionString
// Start of memberFunctionString
/* #line 72 "/workspace/src/ROSETTA/Grammar/Node.code" */
 
     public:
 
          void set_isModified( bool isModified );
 
          void set_containsTransformation( bool containsTransformation );
 
 
          bool get_isModified() const;
 
          bool get_containsTransformation() const;
 
#if 0
       // DQ (5/2/2021): I think we need a flag to record when a transformation is contained directly in the current file.
          void set_containsTransformationRelativeToNodeFile( bool containsTransformationRelativeToNodeFile );
 
          bool get_containsTransformationRelativeToNodeFile() const;
#endif
          void set_parent ( SgNode* parent );
 
          SgNode* get_parent () const;
 
       // DQ (3/4/2022): Added access function for p_parent for debugging.
          SgNode* get_raw_parent () const;
 
          bool isChild ( SgNode* node ) const;
 
        // DQ (4/4/2006): Added optional parameter to customize unparsing
        // virtual std::string unparseToString(SgUnparse_Info* info = NULL) const;
        // Jeremiah (11/9/2007): The default value is not recognized by gdb.
           virtual std::string unparseToString(SgUnparse_Info* info) const;
 
        // DQ (9/6/2010): Move this to the source file (we want to eliminate function definitions in header files).
        // The existence of this function addresses a bug in gdb (see comment from Jeremiah (11/9/2007) above).
        // inline std::string unparseToString() const { return this->unparseToString(NULL); }
           std::string unparseToString() const;
 
          std::string unparseToCompleteString();
 
          static std::vector<std::string> buildCommandLineToSubstituteTransformationFile( const std::vector<std::string>& argv, std::string newFileName );
 
       // JJW (10/16/2008): Replace variant() by variantT() and a cast (the
       // numbers are the same, but the enumerator names are different)
          int variant() const ROSE_DEPRECATED_FUNCTION {return (int)this->variantT();}
 
       // AS (10/22/2007): build function to return class hierachy subtree of a VariantT
          static std::vector<VariantT> getClassHierarchySubTreeFunction( VariantT v);
          static void getClassHierarchySubTreeFunction( VariantT v, std::vector<VariantT>&);
 
          bool get_isVisited () const ROSE_DEPRECATED_FUNCTION;
 
          void set_isVisited ( bool isVisited ) ROSE_DEPRECATED_FUNCTION;
 
          static std::map<SgNode*,std::string> & get_globalMangledNameMap();
 
          static void clearGlobalMangledNameMap();
 
          static std::map<std::string, uint64_t> & get_shortMangledNameCache();
 
 
          static std::map<SgNode*,std::string> & get_globalQualifiedNameMapForNames();
 
          static void set_globalQualifiedNameMapForNames ( const std::map<SgNode*,std::string> & X );
 
          static std::map<SgNode*,std::string> & get_globalQualifiedNameMapForTypes();
 
          static void set_globalQualifiedNameMapForTypes ( const std::map<SgNode*,std::string> & X );
 
       // DQ (3/13/2019): Added name qualification support for references to types than can embed many types.
          static std::map<SgNode*,std::map<SgNode*,std::string> > & get_globalQualifiedNameMapForMapsOfTypes();
 
       // DQ (3/13/2019): Added name qualification support for references to types than can embed many types.
          static void set_globalQualifiedNameMapForMapsOfTypes ( const std::map<SgNode*,std::map<SgNode*,std::string> > & X );
 
          static std::map<SgNode*,std::string> & get_globalQualifiedNameMapForTemplateHeaders();
 
          static void set_globalQualifiedNameMapForTemplateHeaders ( const std::map<SgNode*,std::string> & X );
 
          static std::map<SgNode*,std::string> & get_globalTypeNameMap();
 
          static void set_globalTypeNameMap ( const std::map<SgNode*,std::string> & X );
 
     /* name Persistant Attribute Mechanism
 
         This is the persistant attribute mechanism for attaching attributed to IR nodes across
         multiple passes. Note that these attributes are persistant in that they are preserved
         if the AST is written out to a file and read in from a file.  However, virtual function
         in the user-defined class derived from the AstAttribute must be defined for the attribute
         to be defined across the boundary of File I/O (simple pack and unpack functions).  More
         sophisticated mechanisms are available within the AstAttributeMechanism object
         (e.g iterating though attributes, etc; get_attributeMechanism() is available if direct
         access is required, however mostly only internal tools use this lower level support).
 
         \internal This used to be a public data member, but has been changed to be a protected
         pointer instead.  The functional interface of the AstAttributeMechanism is presevered
         but some of the names and the syntax for calling the interface have changed. The
         pointer to the AstAttributeMechanism is now generated by ROSETTA.
      */
     /* */
         virtual void addNewAttribute(std::string s,AstAttribute* a);
         virtual AstAttribute* getAttribute(std::string s) const;
         virtual void updateAttribute(std::string s,AstAttribute* a);  // formerly called: replace in AstAttributeMechanism
         virtual void setAttribute(std::string s,AstAttribute* a);
         virtual void removeAttribute(std::string s);
         virtual bool attributeExists(std::string s) const;
         virtual int numberOfAttributes() const;
 
         virtual AstAttributeMechanism* get_attributeMechanism() const;
         virtual void set_attributeMechanism(AstAttributeMechanism* a);
     /* */
 
#if ALT_FIXUP_COPY
      /* name AST Copy Support Functions
 
          Support for IR node specific fixup of copy operation.
          This function helps reset scopes and build untraversed parts of the
          AST that are difficult to have be constructed using the automatically
          generated copy functions.
 
          \implementation These functions are used internally inside the AST copy mechanism.
           The public interface for this functionality is given below this section.
       */
      /* */
          virtual void fixupCopy_scopes     (SgNode* copy, SgCopyHelp & help) const;
          virtual void fixupCopy_symbols    (SgNode* copy, SgCopyHelp & help) const;
          virtual void fixupCopy_references (SgNode* copy, SgCopyHelp & help) const;
      /* */
#else
          virtual void fixupCopy(SgNode* copy, SgCopyHelp & help) const;
#endif
 
      /* name Source Position Information
          \brief Support for source code position information of all IR nodes.
 
          These are the virtual function definitions, they are overloaded for SgLocatedNode
          and a few of the SgSupport IR nodes.
       */
      /* */
          virtual Sg_File_Info* get_file_info(void) const { return nullptr; }
 
          virtual Sg_File_Info* get_startOfConstruct(void) const {return nullptr;}
 
          virtual Sg_File_Info* get_endOfConstruct(void) const { return nullptr; }
      /* */
 
      /* name Control flow graph public functions
 
          These functions return control flow graph nodes for various positions
          around a construct. */
      /* */
 
#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
          VirtualCFG::CFGNode cfgForBeginning();
          VirtualCFG::CFGNode cfgForEnd();
#endif
 
#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
      /* name Control flow graph view helper functions
 
          These functions are used internally inside the control flow graph
          view code.  The public interface for this functionality is given
          below this section. */
      /* */
 
          virtual unsigned int cfgIndexForEnd() const;
 
          virtual bool cfgIsIndexInteresting(unsigned int index) const;
 
          virtual unsigned int cfgFindChildIndex(SgNode* n);
 
          virtual unsigned int cfgFindNextChildIndex(SgNode* n);
 
          virtual std::vector<VirtualCFG::CFGEdge> cfgOutEdges(unsigned int index = false);
 
          virtual std::vector<VirtualCFG::CFGEdge> cfgInEdges(unsigned int index = false);
#endif
      /* */
 
       // DQ (1/31/2006): These must be built to be static access member functions (so they can't be built by ROSETTA).
      /* name Function Type Information
             Support for global view of function types used in ROSE.
       */
      /* */
          static SgFunctionTypeTable* get_globalFunctionTypeTable();
          static void set_globalFunctionTypeTable(SgFunctionTypeTable* globalFunctionTypeTable);
      /* */
 
       // DQ (7/22/2010): Added seperate type table to support construction of unique types.
          static SgTypeTable* get_globalTypeTable();
          static void set_globalTypeTable(SgTypeTable* globalTypeTable);
 
     protected:
          static std::vector<std::tuple<unsigned char*, unsigned, VariantT>> all_pools;
     public:
          static VariantT variantFromPool(SgNode const * n);
 
      /* \brief Mangled name cache for improved performance of mangled name generation
          This mangle name caching is implemented to support better performance.
       */
       // static std::map<SgNode*,std::string> & get_globalMangledNameMap();
 
          int numberOfNodesInSubtree();
 
          int depthOfSubtree();
 
     protected:
 
          virtual void post_construction_initialization();
 
     private:
       // Make the copy constructor private (to avoid it being used)
       /* We have to make the copy constructor available so that the SgUnparse_Info
          copy constructor can access it, I'm not clear if this is a good idea.
        */
       // SgNode(const SgNode &); /* private so it can't be used. */
 
          SgNode & operator= (const SgNode &) = delete;
 
public:
    template<class T>
    static typename std::enable_if<std::is_base_of<SgNode, T>::value, T*>::type
    createAndParent(SgNode *parent) {
        auto node = new T;
        node->set_parent(parent);
        return node;
    }
    createAndParent(SgNode *parent) {…}
 
    template<class T>
    T* initParentPointer(T *child, SgNode *parent) {
        ASSERT_not_null(parent);
        if (child) {
#ifndef NDEBUG
            auto toString = [](SgNode *node) {
                if (node) {
                    return (boost::format("(%s*)%p") % node->class_name() % node).str();
                } else {
                    return std::string("nullptr");
                }
            };
 
            ASSERT_require2(child->get_parent() == nullptr,
                            "child " + toString(child) +
                            " cannot be inserted into " + toString(parent) +
                            " because it is already a child of " + toString(child->get_parent()));
#endif
            child->set_parent(this);
        }
        return child;
    }
    T* initParentPointer(T *child, SgNode *parent) {…}
 
    template<class T>
    typename std::enable_if<
        std::is_pointer<T>::value,
        void>::type
    changeChildPointer(T& edge, T const& child) {
#ifndef NDEBUG
        auto toString = [](SgNode *node) {
            if (node) {
                return (boost::format("(%s*)%p") % node->class_name() % node).str();
            } else {
                return std::string("nullptr");
            }
        };
#endif
 
        if (child != edge) {
            // If there is an old child, check that it has the correct parent and then remove it.
            if (edge) {
                ASSERT_require2(edge->get_parent() == this,
                                "node " + toString(edge) +
                                " is a child of " + toString(this) +
                                " but has wrong parent " + toString(edge->get_parent()));
                edge->set_parent(nullptr);
                edge = nullptr;
            }
 
            // If there is a new child, check its parent pointer and then insert it.
            if (child) {
                ASSERT_require2(child->get_parent() == nullptr,
                                "node " + toString(child) +
                                " is to be a child of " + toString(this) +
                                " but is already a child of " + toString(child->get_parent()));
                child->set_parent(this);
                edge = child;
            }
        }
    }
    changeChildPointer(T& edge, T const& child) {…}
 
    // This gets called for non-pointers, which is the situation for nodes that are only lists of other nodes. We're currently
    // not checking them because the ROSETTA-generated API has too many ways to get around this check, most of which make it
    // impossible to enforce constraints regarding the parent/child consistency. For example:
    //
    //    node->children().clear(); // removes a whole bunch of children but doesn't clear their parent pointers
    //    node->children()[i] = child; // changes the ith child, but doesn't clear the previous ith child's parent pointer
    //    for (auto &tmp: node->children()) tmp = nullptr; // changes each child but doesn't clear parent pointers
    //    ad nausiam...
    template<class T>
    typename std::enable_if<
        !std::is_pointer<T>::value,
        void>::type
    changeChildPointer(T& edge, T const& child) {
        edge = child;
    }
    changeChildPointer(T& edge, T const& child) {…}
private:
    // This is called by the debugSerializationBegin and debugSerializationEnd that are in turn called at the beginning and end of
    // each AST node's serialization function. The implementation below uses two counters: classSerializationDepth shared by all
    // instances of this class, and objectSerializationDepth_ which is a per-instance counter. The relationship of these two
    // counters can tell us how deeply nested these recursive calls are, and which of those recursion levels are due to traversing
    // through the base classes versus traversing through data members. In the output, we use one character of indentation per
    // recursion level, with spaces (' ') representing recursion due to data members and dots ('.') representing recursion due to
    // base classes.
#if 0
    // Debugging version
    size_t objectSerializationDepth_ = 0;               // incremented as we traverse through base classes
    void debugSerializationHelper(const char *className, bool isBegin) {
        static size_t classSerializationDepth = 0;      // incremented by both base classes and data members
        if (isBegin) {
            ASSERT_require(classSerializationDepth >= objectSerializationDepth_);
            const size_t memberTraversalDepth = classSerializationDepth - objectSerializationDepth_;
            std::cerr <<"serializing: " <<std::string(memberTraversalDepth, ' ') <<std::string(objectSerializationDepth_, '.')
                      <<className <<" " <<this <<"\n";
            ++classSerializationDepth;
            ++objectSerializationDepth_;
        } else {
            ASSERT_require2(classSerializationDepth > 0, className);
            ASSERT_require2(objectSerializationDepth_ > 0, className);
            --classSerializationDepth;
            --objectSerializationDepth_;
        }
    }
#else
    // Production version
    void debugSerializationHelper(const char*, bool) {}
#endif
 
protected:
     virtual void destructorHelper() {}
 
protected:
    virtual void debugSerializationBegin(const char *className) {
        debugSerializationHelper(className, true);
    }
    virtual void debugSerializationBegin(const char *className) {…}
    virtual void debugSerializationEnd(const char *className) {
        debugSerializationHelper(className, false);
    }
    virtual void debugSerializationEnd(const char *className) {…}
     public:
 
 
 
// End of memberFunctionString
 
 
 
 
     public: 
         SgNode* get_freepointer() const;
         void set_freepointer(SgNode* freepointer);
 
 
 
 
 
 
 
 
 
 
 
     public: 
         virtual ~SgNode();
 
 
     public: 
         SgNode(); 
 
    protected:
// Start of memberFunctionString
SgNode* p_parent;
          
// End of memberFunctionString
// Start of memberFunctionString
bool p_isModified;
          
// End of memberFunctionString
// Start of memberFunctionString
bool p_containsTransformation;
          
// End of memberFunctionString
// Start of memberFunctionString
SgNode* p_freepointer;
          
// End of memberFunctionString
// Start of memberFunctionString
static SgFunctionTypeTable* p_globalFunctionTypeTable;
          
// End of memberFunctionString
// Start of memberFunctionString
static SgTypeTable* p_globalTypeTable;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::string> p_globalMangledNameMap;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<std::string, uint64_t> p_shortMangledNameCache;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::string> p_globalQualifiedNameMapForNames;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::string> p_globalQualifiedNameMapForTypes;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::string> p_globalQualifiedNameMapForTemplateHeaders;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::string> p_globalTypeNameMap;
          
// End of memberFunctionString
// Start of memberFunctionString
static std::map<SgNode*,std::map<SgNode*,std::string> > p_globalQualifiedNameMapForMapsOfTypes;
          
// End of memberFunctionString
 
    friend struct Rose::Traits::generated::describe_node_t<SgNode>;
    friend struct Rose::Traits::generated::describe_field_t<SgNode, SgNode*,&SgNode::p_parent>;
    friend struct Rose::Traits::generated::describe_field_t<SgNode, bool,&SgNode::p_isModified>;
    friend struct Rose::Traits::generated::describe_field_t<SgNode, bool,&SgNode::p_containsTransformation>;
    friend struct Rose::Traits::generated::describe_field_t<SgNode, SgNode*,&SgNode::p_freepointer>;
 
/* #line 21 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
 
   };
#endif
 
// postdeclarations for SgNode
 
/* #line 1238 "../../../src/frontend/SageIII//SgNode.h" */
 
/* #line 27 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $POSTDECLARATIONS" */
 
/* #line 28 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
 
/* #line 1245 "../../../src/frontend/SageIII//SgNode.h" */
 
#endif // ROSE_SgNode_H