Cxx_GrammarMemoryPoolSupport.h

Go to the documentation of this file.

// MACHINE GENERATED SOURCE FILE --- DO NOT MODIFY! (Grammar.C) 


// generated file
/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgNode_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgNode* SgNode_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgNode_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgNode* SgNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgNode* SgNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgNode_clearMemoryPool ( );
void SgNode_extendMemoryPoolForFileIO ( );
unsigned long SgNode_initializeStorageClassArray( SgNodeStorageClass *storageArray );
void SgNode_resetValidFreepointers( );
unsigned long SgNode_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgSupport_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgSupport* SgSupport_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgSupport_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgSupport* SgSupport_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgSupport* SgSupport_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgSupport_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgSupport_clearMemoryPool ( );
void SgSupport_extendMemoryPoolForFileIO ( );
unsigned long SgSupport_initializeStorageClassArray( SgSupportStorageClass *storageArray );
void SgSupport_resetValidFreepointers( );
unsigned long SgSupport_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgModifier* SgModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgModifier* SgModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgModifier* SgModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgModifier_clearMemoryPool ( );
void SgModifier_extendMemoryPoolForFileIO ( );
unsigned long SgModifier_initializeStorageClassArray( SgModifierStorageClass *storageArray );
void SgModifier_resetValidFreepointers( );
unsigned long SgModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgModifierNodes_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgModifierNodes* SgModifierNodes_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgModifierNodes_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgModifierNodes* SgModifierNodes_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgModifierNodes* SgModifierNodes_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgModifierNodes_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgModifierNodes_clearMemoryPool ( );
void SgModifierNodes_extendMemoryPoolForFileIO ( );
unsigned long SgModifierNodes_initializeStorageClassArray( SgModifierNodesStorageClass *storageArray );
void SgModifierNodes_resetValidFreepointers( );
unsigned long SgModifierNodes_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgConstVolatileModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgConstVolatileModifier* SgConstVolatileModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgConstVolatileModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgConstVolatileModifier* SgConstVolatileModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgConstVolatileModifier* SgConstVolatileModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgConstVolatileModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgConstVolatileModifier_clearMemoryPool ( );
void SgConstVolatileModifier_extendMemoryPoolForFileIO ( );
unsigned long SgConstVolatileModifier_initializeStorageClassArray( SgConstVolatileModifierStorageClass *storageArray );
void SgConstVolatileModifier_resetValidFreepointers( );
unsigned long SgConstVolatileModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgStorageModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgStorageModifier* SgStorageModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgStorageModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgStorageModifier* SgStorageModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgStorageModifier* SgStorageModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgStorageModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgStorageModifier_clearMemoryPool ( );
void SgStorageModifier_extendMemoryPoolForFileIO ( );
unsigned long SgStorageModifier_initializeStorageClassArray( SgStorageModifierStorageClass *storageArray );
void SgStorageModifier_resetValidFreepointers( );
unsigned long SgStorageModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgAccessModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgAccessModifier* SgAccessModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgAccessModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgAccessModifier* SgAccessModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgAccessModifier* SgAccessModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgAccessModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgAccessModifier_clearMemoryPool ( );
void SgAccessModifier_extendMemoryPoolForFileIO ( );
unsigned long SgAccessModifier_initializeStorageClassArray( SgAccessModifierStorageClass *storageArray );
void SgAccessModifier_resetValidFreepointers( );
unsigned long SgAccessModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFunctionModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFunctionModifier* SgFunctionModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFunctionModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFunctionModifier* SgFunctionModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFunctionModifier* SgFunctionModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFunctionModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFunctionModifier_clearMemoryPool ( );
void SgFunctionModifier_extendMemoryPoolForFileIO ( );
unsigned long SgFunctionModifier_initializeStorageClassArray( SgFunctionModifierStorageClass *storageArray );
void SgFunctionModifier_resetValidFreepointers( );
unsigned long SgFunctionModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgUPC_AccessModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgUPC_AccessModifier* SgUPC_AccessModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgUPC_AccessModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgUPC_AccessModifier* SgUPC_AccessModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgUPC_AccessModifier* SgUPC_AccessModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgUPC_AccessModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgUPC_AccessModifier_clearMemoryPool ( );
void SgUPC_AccessModifier_extendMemoryPoolForFileIO ( );
unsigned long SgUPC_AccessModifier_initializeStorageClassArray( SgUPC_AccessModifierStorageClass *storageArray );
void SgUPC_AccessModifier_resetValidFreepointers( );
unsigned long SgUPC_AccessModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgSpecialFunctionModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgSpecialFunctionModifier* SgSpecialFunctionModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgSpecialFunctionModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgSpecialFunctionModifier* SgSpecialFunctionModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgSpecialFunctionModifier* SgSpecialFunctionModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgSpecialFunctionModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgSpecialFunctionModifier_clearMemoryPool ( );
void SgSpecialFunctionModifier_extendMemoryPoolForFileIO ( );
unsigned long SgSpecialFunctionModifier_initializeStorageClassArray( SgSpecialFunctionModifierStorageClass *storageArray );
void SgSpecialFunctionModifier_resetValidFreepointers( );
unsigned long SgSpecialFunctionModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgElaboratedTypeModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgElaboratedTypeModifier* SgElaboratedTypeModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgElaboratedTypeModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgElaboratedTypeModifier* SgElaboratedTypeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgElaboratedTypeModifier* SgElaboratedTypeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgElaboratedTypeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgElaboratedTypeModifier_clearMemoryPool ( );
void SgElaboratedTypeModifier_extendMemoryPoolForFileIO ( );
unsigned long SgElaboratedTypeModifier_initializeStorageClassArray( SgElaboratedTypeModifierStorageClass *storageArray );
void SgElaboratedTypeModifier_resetValidFreepointers( );
unsigned long SgElaboratedTypeModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgLinkageModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgLinkageModifier* SgLinkageModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgLinkageModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgLinkageModifier* SgLinkageModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgLinkageModifier* SgLinkageModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgLinkageModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgLinkageModifier_clearMemoryPool ( );
void SgLinkageModifier_extendMemoryPoolForFileIO ( );
unsigned long SgLinkageModifier_initializeStorageClassArray( SgLinkageModifierStorageClass *storageArray );
void SgLinkageModifier_resetValidFreepointers( );
unsigned long SgLinkageModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgBaseClassModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgBaseClassModifier* SgBaseClassModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgBaseClassModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgBaseClassModifier* SgBaseClassModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgBaseClassModifier* SgBaseClassModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgBaseClassModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgBaseClassModifier_clearMemoryPool ( );
void SgBaseClassModifier_extendMemoryPoolForFileIO ( );
unsigned long SgBaseClassModifier_initializeStorageClassArray( SgBaseClassModifierStorageClass *storageArray );
void SgBaseClassModifier_resetValidFreepointers( );
unsigned long SgBaseClassModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeModifier* SgTypeModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeModifier* SgTypeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeModifier* SgTypeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeModifier_clearMemoryPool ( );
void SgTypeModifier_extendMemoryPoolForFileIO ( );
unsigned long SgTypeModifier_initializeStorageClassArray( SgTypeModifierStorageClass *storageArray );
void SgTypeModifier_resetValidFreepointers( );
unsigned long SgTypeModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDeclarationModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDeclarationModifier* SgDeclarationModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDeclarationModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDeclarationModifier* SgDeclarationModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDeclarationModifier* SgDeclarationModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDeclarationModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDeclarationModifier_clearMemoryPool ( );
void SgDeclarationModifier_extendMemoryPoolForFileIO ( );
unsigned long SgDeclarationModifier_initializeStorageClassArray( SgDeclarationModifierStorageClass *storageArray );
void SgDeclarationModifier_resetValidFreepointers( );
unsigned long SgDeclarationModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgOpenclAccessModeModifier_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgOpenclAccessModeModifier_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgOpenclAccessModeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgOpenclAccessModeModifier_clearMemoryPool ( );
void SgOpenclAccessModeModifier_extendMemoryPoolForFileIO ( );
unsigned long SgOpenclAccessModeModifier_initializeStorageClassArray( SgOpenclAccessModeModifierStorageClass *storageArray );
void SgOpenclAccessModeModifier_resetValidFreepointers( );
unsigned long SgOpenclAccessModeModifier_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgName_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgName* SgName_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgName_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgName* SgName_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgName* SgName_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgName_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgName_clearMemoryPool ( );
void SgName_extendMemoryPoolForFileIO ( );
unsigned long SgName_initializeStorageClassArray( SgNameStorageClass *storageArray );
void SgName_resetValidFreepointers( );
unsigned long SgName_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgSymbolTable_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgSymbolTable* SgSymbolTable_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgSymbolTable_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgSymbolTable* SgSymbolTable_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgSymbolTable* SgSymbolTable_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgSymbolTable_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgSymbolTable_clearMemoryPool ( );
void SgSymbolTable_extendMemoryPoolForFileIO ( );
unsigned long SgSymbolTable_initializeStorageClassArray( SgSymbolTableStorageClass *storageArray );
void SgSymbolTable_resetValidFreepointers( );
unsigned long SgSymbolTable_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgAttribute_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgAttribute* SgAttribute_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgAttribute_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgAttribute* SgAttribute_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgAttribute* SgAttribute_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgAttribute_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgAttribute_clearMemoryPool ( );
void SgAttribute_extendMemoryPoolForFileIO ( );
unsigned long SgAttribute_initializeStorageClassArray( SgAttributeStorageClass *storageArray );
void SgAttribute_resetValidFreepointers( );
unsigned long SgAttribute_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgPragma_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgPragma* SgPragma_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgPragma_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgPragma* SgPragma_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgPragma* SgPragma_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgPragma_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgPragma_clearMemoryPool ( );
void SgPragma_extendMemoryPoolForFileIO ( );
unsigned long SgPragma_initializeStorageClassArray( SgPragmaStorageClass *storageArray );
void SgPragma_resetValidFreepointers( );
unsigned long SgPragma_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgBitAttribute_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgBitAttribute* SgBitAttribute_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgBitAttribute_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgBitAttribute* SgBitAttribute_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgBitAttribute* SgBitAttribute_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgBitAttribute_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgBitAttribute_clearMemoryPool ( );
void SgBitAttribute_extendMemoryPoolForFileIO ( );
unsigned long SgBitAttribute_initializeStorageClassArray( SgBitAttributeStorageClass *storageArray );
void SgBitAttribute_resetValidFreepointers( );
unsigned long SgBitAttribute_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFuncDecl_attr_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFuncDecl_attr* SgFuncDecl_attr_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFuncDecl_attr_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFuncDecl_attr* SgFuncDecl_attr_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFuncDecl_attr* SgFuncDecl_attr_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFuncDecl_attr_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFuncDecl_attr_clearMemoryPool ( );
void SgFuncDecl_attr_extendMemoryPoolForFileIO ( );
unsigned long SgFuncDecl_attr_initializeStorageClassArray( SgFuncDecl_attrStorageClass *storageArray );
void SgFuncDecl_attr_resetValidFreepointers( );
unsigned long SgFuncDecl_attr_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgClassDecl_attr_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgClassDecl_attr* SgClassDecl_attr_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgClassDecl_attr_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgClassDecl_attr* SgClassDecl_attr_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgClassDecl_attr* SgClassDecl_attr_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgClassDecl_attr_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgClassDecl_attr_clearMemoryPool ( );
void SgClassDecl_attr_extendMemoryPoolForFileIO ( );
unsigned long SgClassDecl_attr_initializeStorageClassArray( SgClassDecl_attrStorageClass *storageArray );
void SgClassDecl_attr_resetValidFreepointers( );
unsigned long SgClassDecl_attr_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int Sg_File_Info_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern Sg_File_Info* Sg_File_Info_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > Sg_File_Info_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
Sg_File_Info* Sg_File_Info_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
Sg_File_Info* Sg_File_Info_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long Sg_File_Info_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void Sg_File_Info_clearMemoryPool ( );
void Sg_File_Info_extendMemoryPoolForFileIO ( );
unsigned long Sg_File_Info_initializeStorageClassArray( Sg_File_InfoStorageClass *storageArray );
void Sg_File_Info_resetValidFreepointers( );
unsigned long Sg_File_Info_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFile_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFile* SgFile_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFile_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFile* SgFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFile* SgFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFile_clearMemoryPool ( );
void SgFile_extendMemoryPoolForFileIO ( );
unsigned long SgFile_initializeStorageClassArray( SgFileStorageClass *storageArray );
void SgFile_resetValidFreepointers( );
unsigned long SgFile_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgSourceFile_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgSourceFile* SgSourceFile_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgSourceFile_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgSourceFile* SgSourceFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgSourceFile* SgSourceFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgSourceFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgSourceFile_clearMemoryPool ( );
void SgSourceFile_extendMemoryPoolForFileIO ( );
unsigned long SgSourceFile_initializeStorageClassArray( SgSourceFileStorageClass *storageArray );
void SgSourceFile_resetValidFreepointers( );
unsigned long SgSourceFile_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgBinaryComposite_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgBinaryComposite* SgBinaryComposite_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgBinaryComposite_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgBinaryComposite* SgBinaryComposite_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgBinaryComposite* SgBinaryComposite_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgBinaryComposite_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgBinaryComposite_clearMemoryPool ( );
void SgBinaryComposite_extendMemoryPoolForFileIO ( );
unsigned long SgBinaryComposite_initializeStorageClassArray( SgBinaryCompositeStorageClass *storageArray );
void SgBinaryComposite_resetValidFreepointers( );
unsigned long SgBinaryComposite_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgUnknownFile_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgUnknownFile* SgUnknownFile_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgUnknownFile_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgUnknownFile* SgUnknownFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgUnknownFile* SgUnknownFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgUnknownFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgUnknownFile_clearMemoryPool ( );
void SgUnknownFile_extendMemoryPoolForFileIO ( );
unsigned long SgUnknownFile_initializeStorageClassArray( SgUnknownFileStorageClass *storageArray );
void SgUnknownFile_resetValidFreepointers( );
unsigned long SgUnknownFile_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgProject_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgProject* SgProject_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgProject_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgProject* SgProject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgProject* SgProject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgProject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgProject_clearMemoryPool ( );
void SgProject_extendMemoryPoolForFileIO ( );
unsigned long SgProject_initializeStorageClassArray( SgProjectStorageClass *storageArray );
void SgProject_resetValidFreepointers( );
unsigned long SgProject_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgOptions_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgOptions* SgOptions_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgOptions_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgOptions* SgOptions_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgOptions* SgOptions_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgOptions_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgOptions_clearMemoryPool ( );
void SgOptions_extendMemoryPoolForFileIO ( );
unsigned long SgOptions_initializeStorageClassArray( SgOptionsStorageClass *storageArray );
void SgOptions_resetValidFreepointers( );
unsigned long SgOptions_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgUnparse_Info_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgUnparse_Info* SgUnparse_Info_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgUnparse_Info_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgUnparse_Info* SgUnparse_Info_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgUnparse_Info* SgUnparse_Info_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgUnparse_Info_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgUnparse_Info_clearMemoryPool ( );
void SgUnparse_Info_extendMemoryPoolForFileIO ( );
unsigned long SgUnparse_Info_initializeStorageClassArray( SgUnparse_InfoStorageClass *storageArray );
void SgUnparse_Info_resetValidFreepointers( );
unsigned long SgUnparse_Info_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgBaseClass_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgBaseClass* SgBaseClass_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgBaseClass_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgBaseClass* SgBaseClass_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgBaseClass* SgBaseClass_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgBaseClass_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgBaseClass_clearMemoryPool ( );
void SgBaseClass_extendMemoryPoolForFileIO ( );
unsigned long SgBaseClass_initializeStorageClassArray( SgBaseClassStorageClass *storageArray );
void SgBaseClass_resetValidFreepointers( );
unsigned long SgBaseClass_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgExpBaseClass_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgExpBaseClass* SgExpBaseClass_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgExpBaseClass_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgExpBaseClass* SgExpBaseClass_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgExpBaseClass* SgExpBaseClass_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgExpBaseClass_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgExpBaseClass_clearMemoryPool ( );
void SgExpBaseClass_extendMemoryPoolForFileIO ( );
unsigned long SgExpBaseClass_initializeStorageClassArray( SgExpBaseClassStorageClass *storageArray );
void SgExpBaseClass_resetValidFreepointers( );
unsigned long SgExpBaseClass_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypedefSeq_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypedefSeq* SgTypedefSeq_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypedefSeq_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypedefSeq* SgTypedefSeq_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypedefSeq* SgTypedefSeq_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypedefSeq_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypedefSeq_clearMemoryPool ( );
void SgTypedefSeq_extendMemoryPoolForFileIO ( );
unsigned long SgTypedefSeq_initializeStorageClassArray( SgTypedefSeqStorageClass *storageArray );
void SgTypedefSeq_resetValidFreepointers( );
unsigned long SgTypedefSeq_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTemplateParameter_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTemplateParameter* SgTemplateParameter_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTemplateParameter_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTemplateParameter* SgTemplateParameter_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTemplateParameter* SgTemplateParameter_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTemplateParameter_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTemplateParameter_clearMemoryPool ( );
void SgTemplateParameter_extendMemoryPoolForFileIO ( );
unsigned long SgTemplateParameter_initializeStorageClassArray( SgTemplateParameterStorageClass *storageArray );
void SgTemplateParameter_resetValidFreepointers( );
unsigned long SgTemplateParameter_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTemplateArgument_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTemplateArgument* SgTemplateArgument_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTemplateArgument_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTemplateArgument* SgTemplateArgument_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTemplateArgument* SgTemplateArgument_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTemplateArgument_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTemplateArgument_clearMemoryPool ( );
void SgTemplateArgument_extendMemoryPoolForFileIO ( );
unsigned long SgTemplateArgument_initializeStorageClassArray( SgTemplateArgumentStorageClass *storageArray );
void SgTemplateArgument_resetValidFreepointers( );
unsigned long SgTemplateArgument_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDirectory_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDirectory* SgDirectory_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDirectory_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDirectory* SgDirectory_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDirectory* SgDirectory_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDirectory_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDirectory_clearMemoryPool ( );
void SgDirectory_extendMemoryPoolForFileIO ( );
unsigned long SgDirectory_initializeStorageClassArray( SgDirectoryStorageClass *storageArray );
void SgDirectory_resetValidFreepointers( );
unsigned long SgDirectory_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFileList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFileList* SgFileList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFileList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFileList* SgFileList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFileList* SgFileList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFileList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFileList_clearMemoryPool ( );
void SgFileList_extendMemoryPoolForFileIO ( );
unsigned long SgFileList_initializeStorageClassArray( SgFileListStorageClass *storageArray );
void SgFileList_resetValidFreepointers( );
unsigned long SgFileList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDirectoryList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDirectoryList* SgDirectoryList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDirectoryList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDirectoryList* SgDirectoryList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDirectoryList* SgDirectoryList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDirectoryList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDirectoryList_clearMemoryPool ( );
void SgDirectoryList_extendMemoryPoolForFileIO ( );
unsigned long SgDirectoryList_initializeStorageClassArray( SgDirectoryListStorageClass *storageArray );
void SgDirectoryList_resetValidFreepointers( );
unsigned long SgDirectoryList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFunctionParameterTypeList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFunctionParameterTypeList* SgFunctionParameterTypeList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFunctionParameterTypeList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFunctionParameterTypeList* SgFunctionParameterTypeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFunctionParameterTypeList* SgFunctionParameterTypeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFunctionParameterTypeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFunctionParameterTypeList_clearMemoryPool ( );
void SgFunctionParameterTypeList_extendMemoryPoolForFileIO ( );
unsigned long SgFunctionParameterTypeList_initializeStorageClassArray( SgFunctionParameterTypeListStorageClass *storageArray );
void SgFunctionParameterTypeList_resetValidFreepointers( );
unsigned long SgFunctionParameterTypeList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgQualifiedName_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgQualifiedName* SgQualifiedName_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgQualifiedName_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgQualifiedName* SgQualifiedName_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgQualifiedName* SgQualifiedName_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgQualifiedName_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgQualifiedName_clearMemoryPool ( );
void SgQualifiedName_extendMemoryPoolForFileIO ( );
unsigned long SgQualifiedName_initializeStorageClassArray( SgQualifiedNameStorageClass *storageArray );
void SgQualifiedName_resetValidFreepointers( );
unsigned long SgQualifiedName_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTemplateArgumentList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTemplateArgumentList* SgTemplateArgumentList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTemplateArgumentList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTemplateArgumentList* SgTemplateArgumentList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTemplateArgumentList* SgTemplateArgumentList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTemplateArgumentList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTemplateArgumentList_clearMemoryPool ( );
void SgTemplateArgumentList_extendMemoryPoolForFileIO ( );
unsigned long SgTemplateArgumentList_initializeStorageClassArray( SgTemplateArgumentListStorageClass *storageArray );
void SgTemplateArgumentList_resetValidFreepointers( );
unsigned long SgTemplateArgumentList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTemplateParameterList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTemplateParameterList* SgTemplateParameterList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTemplateParameterList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTemplateParameterList* SgTemplateParameterList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTemplateParameterList* SgTemplateParameterList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTemplateParameterList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTemplateParameterList_clearMemoryPool ( );
void SgTemplateParameterList_extendMemoryPoolForFileIO ( );
unsigned long SgTemplateParameterList_initializeStorageClassArray( SgTemplateParameterListStorageClass *storageArray );
void SgTemplateParameterList_resetValidFreepointers( );
unsigned long SgTemplateParameterList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgGraph* SgGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgGraph* SgGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgGraph* SgGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgGraph_clearMemoryPool ( );
void SgGraph_extendMemoryPoolForFileIO ( );
unsigned long SgGraph_initializeStorageClassArray( SgGraphStorageClass *storageArray );
void SgGraph_resetValidFreepointers( );
unsigned long SgGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgIncidenceDirectedGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgIncidenceDirectedGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgIncidenceDirectedGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgIncidenceDirectedGraph_clearMemoryPool ( );
void SgIncidenceDirectedGraph_extendMemoryPoolForFileIO ( );
unsigned long SgIncidenceDirectedGraph_initializeStorageClassArray( SgIncidenceDirectedGraphStorageClass *storageArray );
void SgIncidenceDirectedGraph_resetValidFreepointers( );
unsigned long SgIncidenceDirectedGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgBidirectionalGraph* SgBidirectionalGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgBidirectionalGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgBidirectionalGraph* SgBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgBidirectionalGraph* SgBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgBidirectionalGraph_clearMemoryPool ( );
void SgBidirectionalGraph_extendMemoryPoolForFileIO ( );
unsigned long SgBidirectionalGraph_initializeStorageClassArray( SgBidirectionalGraphStorageClass *storageArray );
void SgBidirectionalGraph_resetValidFreepointers( );
unsigned long SgBidirectionalGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgStringKeyedBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgStringKeyedBidirectionalGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgStringKeyedBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgStringKeyedBidirectionalGraph_clearMemoryPool ( );
void SgStringKeyedBidirectionalGraph_extendMemoryPoolForFileIO ( );
unsigned long SgStringKeyedBidirectionalGraph_initializeStorageClassArray( SgStringKeyedBidirectionalGraphStorageClass *storageArray );
void SgStringKeyedBidirectionalGraph_resetValidFreepointers( );
unsigned long SgStringKeyedBidirectionalGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgIntKeyedBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgIntKeyedBidirectionalGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgIntKeyedBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgIntKeyedBidirectionalGraph_clearMemoryPool ( );
void SgIntKeyedBidirectionalGraph_extendMemoryPoolForFileIO ( );
unsigned long SgIntKeyedBidirectionalGraph_initializeStorageClassArray( SgIntKeyedBidirectionalGraphStorageClass *storageArray );
void SgIntKeyedBidirectionalGraph_resetValidFreepointers( );
unsigned long SgIntKeyedBidirectionalGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgIncidenceUndirectedGraph_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgIncidenceUndirectedGraph_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgIncidenceUndirectedGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgIncidenceUndirectedGraph_clearMemoryPool ( );
void SgIncidenceUndirectedGraph_extendMemoryPoolForFileIO ( );
unsigned long SgIncidenceUndirectedGraph_initializeStorageClassArray( SgIncidenceUndirectedGraphStorageClass *storageArray );
void SgIncidenceUndirectedGraph_resetValidFreepointers( );
unsigned long SgIncidenceUndirectedGraph_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgGraphNode_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgGraphNode* SgGraphNode_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgGraphNode_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgGraphNode* SgGraphNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgGraphNode* SgGraphNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgGraphNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgGraphNode_clearMemoryPool ( );
void SgGraphNode_extendMemoryPoolForFileIO ( );
unsigned long SgGraphNode_initializeStorageClassArray( SgGraphNodeStorageClass *storageArray );
void SgGraphNode_resetValidFreepointers( );
unsigned long SgGraphNode_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgGraphEdge_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgGraphEdge* SgGraphEdge_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgGraphEdge_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgGraphEdge* SgGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgGraphEdge* SgGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgGraphEdge_clearMemoryPool ( );
void SgGraphEdge_extendMemoryPoolForFileIO ( );
unsigned long SgGraphEdge_initializeStorageClassArray( SgGraphEdgeStorageClass *storageArray );
void SgGraphEdge_resetValidFreepointers( );
unsigned long SgGraphEdge_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDirectedGraphEdge_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDirectedGraphEdge* SgDirectedGraphEdge_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDirectedGraphEdge_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDirectedGraphEdge* SgDirectedGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDirectedGraphEdge* SgDirectedGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDirectedGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDirectedGraphEdge_clearMemoryPool ( );
void SgDirectedGraphEdge_extendMemoryPoolForFileIO ( );
unsigned long SgDirectedGraphEdge_initializeStorageClassArray( SgDirectedGraphEdgeStorageClass *storageArray );
void SgDirectedGraphEdge_resetValidFreepointers( );
unsigned long SgDirectedGraphEdge_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgUndirectedGraphEdge_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgUndirectedGraphEdge* SgUndirectedGraphEdge_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgUndirectedGraphEdge_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgUndirectedGraphEdge* SgUndirectedGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgUndirectedGraphEdge* SgUndirectedGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgUndirectedGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgUndirectedGraphEdge_clearMemoryPool ( );
void SgUndirectedGraphEdge_extendMemoryPoolForFileIO ( );
unsigned long SgUndirectedGraphEdge_initializeStorageClassArray( SgUndirectedGraphEdgeStorageClass *storageArray );
void SgUndirectedGraphEdge_resetValidFreepointers( );
unsigned long SgUndirectedGraphEdge_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgGraphNodeList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgGraphNodeList* SgGraphNodeList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgGraphNodeList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgGraphNodeList* SgGraphNodeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgGraphNodeList* SgGraphNodeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgGraphNodeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgGraphNodeList_clearMemoryPool ( );
void SgGraphNodeList_extendMemoryPoolForFileIO ( );
unsigned long SgGraphNodeList_initializeStorageClassArray( SgGraphNodeListStorageClass *storageArray );
void SgGraphNodeList_resetValidFreepointers( );
unsigned long SgGraphNodeList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgGraphEdgeList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgGraphEdgeList* SgGraphEdgeList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgGraphEdgeList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgGraphEdgeList* SgGraphEdgeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgGraphEdgeList* SgGraphEdgeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgGraphEdgeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgGraphEdgeList_clearMemoryPool ( );
void SgGraphEdgeList_extendMemoryPoolForFileIO ( );
unsigned long SgGraphEdgeList_initializeStorageClassArray( SgGraphEdgeListStorageClass *storageArray );
void SgGraphEdgeList_resetValidFreepointers( );
unsigned long SgGraphEdgeList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeTable_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeTable* SgTypeTable_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeTable_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeTable* SgTypeTable_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeTable* SgTypeTable_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeTable_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeTable_clearMemoryPool ( );
void SgTypeTable_extendMemoryPoolForFileIO ( );
unsigned long SgTypeTable_initializeStorageClassArray( SgTypeTableStorageClass *storageArray );
void SgTypeTable_resetValidFreepointers( );
unsigned long SgTypeTable_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgNameGroup_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgNameGroup* SgNameGroup_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgNameGroup_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgNameGroup* SgNameGroup_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgNameGroup* SgNameGroup_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgNameGroup_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgNameGroup_clearMemoryPool ( );
void SgNameGroup_extendMemoryPoolForFileIO ( );
unsigned long SgNameGroup_initializeStorageClassArray( SgNameGroupStorageClass *storageArray );
void SgNameGroup_resetValidFreepointers( );
unsigned long SgNameGroup_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDimensionObject_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDimensionObject* SgDimensionObject_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDimensionObject_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDimensionObject* SgDimensionObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDimensionObject* SgDimensionObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDimensionObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDimensionObject_clearMemoryPool ( );
void SgDimensionObject_extendMemoryPoolForFileIO ( );
unsigned long SgDimensionObject_initializeStorageClassArray( SgDimensionObjectStorageClass *storageArray );
void SgDimensionObject_resetValidFreepointers( );
unsigned long SgDimensionObject_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFormatItem_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFormatItem* SgFormatItem_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFormatItem_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFormatItem* SgFormatItem_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFormatItem* SgFormatItem_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFormatItem_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFormatItem_clearMemoryPool ( );
void SgFormatItem_extendMemoryPoolForFileIO ( );
unsigned long SgFormatItem_initializeStorageClassArray( SgFormatItemStorageClass *storageArray );
void SgFormatItem_resetValidFreepointers( );
unsigned long SgFormatItem_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFormatItemList_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFormatItemList* SgFormatItemList_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFormatItemList_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFormatItemList* SgFormatItemList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFormatItemList* SgFormatItemList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFormatItemList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFormatItemList_clearMemoryPool ( );
void SgFormatItemList_extendMemoryPoolForFileIO ( );
unsigned long SgFormatItemList_initializeStorageClassArray( SgFormatItemListStorageClass *storageArray );
void SgFormatItemList_resetValidFreepointers( );
unsigned long SgFormatItemList_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDataStatementGroup_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDataStatementGroup* SgDataStatementGroup_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDataStatementGroup_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDataStatementGroup* SgDataStatementGroup_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDataStatementGroup* SgDataStatementGroup_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDataStatementGroup_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDataStatementGroup_clearMemoryPool ( );
void SgDataStatementGroup_extendMemoryPoolForFileIO ( );
unsigned long SgDataStatementGroup_initializeStorageClassArray( SgDataStatementGroupStorageClass *storageArray );
void SgDataStatementGroup_resetValidFreepointers( );
unsigned long SgDataStatementGroup_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDataStatementObject_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDataStatementObject* SgDataStatementObject_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDataStatementObject_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDataStatementObject* SgDataStatementObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDataStatementObject* SgDataStatementObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDataStatementObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDataStatementObject_clearMemoryPool ( );
void SgDataStatementObject_extendMemoryPoolForFileIO ( );
unsigned long SgDataStatementObject_initializeStorageClassArray( SgDataStatementObjectStorageClass *storageArray );
void SgDataStatementObject_resetValidFreepointers( );
unsigned long SgDataStatementObject_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgDataStatementValue_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgDataStatementValue* SgDataStatementValue_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgDataStatementValue_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgDataStatementValue* SgDataStatementValue_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgDataStatementValue* SgDataStatementValue_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgDataStatementValue_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgDataStatementValue_clearMemoryPool ( );
void SgDataStatementValue_extendMemoryPoolForFileIO ( );
unsigned long SgDataStatementValue_initializeStorageClassArray( SgDataStatementValueStorageClass *storageArray );
void SgDataStatementValue_resetValidFreepointers( );
unsigned long SgDataStatementValue_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgType* SgType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgType* SgType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgType* SgType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgType_clearMemoryPool ( );
void SgType_extendMemoryPoolForFileIO ( );
unsigned long SgType_initializeStorageClassArray( SgTypeStorageClass *storageArray );
void SgType_resetValidFreepointers( );
unsigned long SgType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnknown_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnknown* SgTypeUnknown_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnknown_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnknown* SgTypeUnknown_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnknown* SgTypeUnknown_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnknown_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnknown_clearMemoryPool ( );
void SgTypeUnknown_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnknown_initializeStorageClassArray( SgTypeUnknownStorageClass *storageArray );
void SgTypeUnknown_resetValidFreepointers( );
unsigned long SgTypeUnknown_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeChar_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeChar* SgTypeChar_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeChar_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeChar* SgTypeChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeChar* SgTypeChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeChar_clearMemoryPool ( );
void SgTypeChar_extendMemoryPoolForFileIO ( );
unsigned long SgTypeChar_initializeStorageClassArray( SgTypeCharStorageClass *storageArray );
void SgTypeChar_resetValidFreepointers( );
unsigned long SgTypeChar_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeSignedChar_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeSignedChar* SgTypeSignedChar_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeSignedChar_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeSignedChar* SgTypeSignedChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeSignedChar* SgTypeSignedChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeSignedChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeSignedChar_clearMemoryPool ( );
void SgTypeSignedChar_extendMemoryPoolForFileIO ( );
unsigned long SgTypeSignedChar_initializeStorageClassArray( SgTypeSignedCharStorageClass *storageArray );
void SgTypeSignedChar_resetValidFreepointers( );
unsigned long SgTypeSignedChar_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnsignedChar_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnsignedChar* SgTypeUnsignedChar_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnsignedChar_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnsignedChar* SgTypeUnsignedChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnsignedChar* SgTypeUnsignedChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnsignedChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnsignedChar_clearMemoryPool ( );
void SgTypeUnsignedChar_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnsignedChar_initializeStorageClassArray( SgTypeUnsignedCharStorageClass *storageArray );
void SgTypeUnsignedChar_resetValidFreepointers( );
unsigned long SgTypeUnsignedChar_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeShort_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeShort* SgTypeShort_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeShort_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeShort* SgTypeShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeShort* SgTypeShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeShort_clearMemoryPool ( );
void SgTypeShort_extendMemoryPoolForFileIO ( );
unsigned long SgTypeShort_initializeStorageClassArray( SgTypeShortStorageClass *storageArray );
void SgTypeShort_resetValidFreepointers( );
unsigned long SgTypeShort_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeSignedShort_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeSignedShort* SgTypeSignedShort_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeSignedShort_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeSignedShort* SgTypeSignedShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeSignedShort* SgTypeSignedShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeSignedShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeSignedShort_clearMemoryPool ( );
void SgTypeSignedShort_extendMemoryPoolForFileIO ( );
unsigned long SgTypeSignedShort_initializeStorageClassArray( SgTypeSignedShortStorageClass *storageArray );
void SgTypeSignedShort_resetValidFreepointers( );
unsigned long SgTypeSignedShort_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnsignedShort_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnsignedShort* SgTypeUnsignedShort_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnsignedShort_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnsignedShort* SgTypeUnsignedShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnsignedShort* SgTypeUnsignedShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnsignedShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnsignedShort_clearMemoryPool ( );
void SgTypeUnsignedShort_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnsignedShort_initializeStorageClassArray( SgTypeUnsignedShortStorageClass *storageArray );
void SgTypeUnsignedShort_resetValidFreepointers( );
unsigned long SgTypeUnsignedShort_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeInt_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeInt* SgTypeInt_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeInt_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeInt* SgTypeInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeInt* SgTypeInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeInt_clearMemoryPool ( );
void SgTypeInt_extendMemoryPoolForFileIO ( );
unsigned long SgTypeInt_initializeStorageClassArray( SgTypeIntStorageClass *storageArray );
void SgTypeInt_resetValidFreepointers( );
unsigned long SgTypeInt_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeSignedInt_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeSignedInt* SgTypeSignedInt_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeSignedInt_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeSignedInt* SgTypeSignedInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeSignedInt* SgTypeSignedInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeSignedInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeSignedInt_clearMemoryPool ( );
void SgTypeSignedInt_extendMemoryPoolForFileIO ( );
unsigned long SgTypeSignedInt_initializeStorageClassArray( SgTypeSignedIntStorageClass *storageArray );
void SgTypeSignedInt_resetValidFreepointers( );
unsigned long SgTypeSignedInt_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnsignedInt_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnsignedInt* SgTypeUnsignedInt_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnsignedInt_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnsignedInt* SgTypeUnsignedInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnsignedInt* SgTypeUnsignedInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnsignedInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnsignedInt_clearMemoryPool ( );
void SgTypeUnsignedInt_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnsignedInt_initializeStorageClassArray( SgTypeUnsignedIntStorageClass *storageArray );
void SgTypeUnsignedInt_resetValidFreepointers( );
unsigned long SgTypeUnsignedInt_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeLong* SgTypeLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeLong* SgTypeLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeLong* SgTypeLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeLong_clearMemoryPool ( );
void SgTypeLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeLong_initializeStorageClassArray( SgTypeLongStorageClass *storageArray );
void SgTypeLong_resetValidFreepointers( );
unsigned long SgTypeLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeSignedLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeSignedLong* SgTypeSignedLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeSignedLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeSignedLong* SgTypeSignedLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeSignedLong* SgTypeSignedLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeSignedLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeSignedLong_clearMemoryPool ( );
void SgTypeSignedLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeSignedLong_initializeStorageClassArray( SgTypeSignedLongStorageClass *storageArray );
void SgTypeSignedLong_resetValidFreepointers( );
unsigned long SgTypeSignedLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnsignedLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnsignedLong* SgTypeUnsignedLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnsignedLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnsignedLong* SgTypeUnsignedLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnsignedLong* SgTypeUnsignedLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnsignedLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnsignedLong_clearMemoryPool ( );
void SgTypeUnsignedLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnsignedLong_initializeStorageClassArray( SgTypeUnsignedLongStorageClass *storageArray );
void SgTypeUnsignedLong_resetValidFreepointers( );
unsigned long SgTypeUnsignedLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeVoid_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeVoid* SgTypeVoid_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeVoid_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeVoid* SgTypeVoid_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeVoid* SgTypeVoid_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeVoid_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeVoid_clearMemoryPool ( );
void SgTypeVoid_extendMemoryPoolForFileIO ( );
unsigned long SgTypeVoid_initializeStorageClassArray( SgTypeVoidStorageClass *storageArray );
void SgTypeVoid_resetValidFreepointers( );
unsigned long SgTypeVoid_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeGlobalVoid_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeGlobalVoid* SgTypeGlobalVoid_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeGlobalVoid_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeGlobalVoid* SgTypeGlobalVoid_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeGlobalVoid* SgTypeGlobalVoid_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeGlobalVoid_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeGlobalVoid_clearMemoryPool ( );
void SgTypeGlobalVoid_extendMemoryPoolForFileIO ( );
unsigned long SgTypeGlobalVoid_initializeStorageClassArray( SgTypeGlobalVoidStorageClass *storageArray );
void SgTypeGlobalVoid_resetValidFreepointers( );
unsigned long SgTypeGlobalVoid_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeWchar_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeWchar* SgTypeWchar_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeWchar_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeWchar* SgTypeWchar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeWchar* SgTypeWchar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeWchar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeWchar_clearMemoryPool ( );
void SgTypeWchar_extendMemoryPoolForFileIO ( );
unsigned long SgTypeWchar_initializeStorageClassArray( SgTypeWcharStorageClass *storageArray );
void SgTypeWchar_resetValidFreepointers( );
unsigned long SgTypeWchar_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeFloat_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeFloat* SgTypeFloat_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeFloat_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeFloat* SgTypeFloat_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeFloat* SgTypeFloat_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeFloat_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeFloat_clearMemoryPool ( );
void SgTypeFloat_extendMemoryPoolForFileIO ( );
unsigned long SgTypeFloat_initializeStorageClassArray( SgTypeFloatStorageClass *storageArray );
void SgTypeFloat_resetValidFreepointers( );
unsigned long SgTypeFloat_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeDouble_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeDouble* SgTypeDouble_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeDouble_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeDouble* SgTypeDouble_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeDouble* SgTypeDouble_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeDouble_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeDouble_clearMemoryPool ( );
void SgTypeDouble_extendMemoryPoolForFileIO ( );
unsigned long SgTypeDouble_initializeStorageClassArray( SgTypeDoubleStorageClass *storageArray );
void SgTypeDouble_resetValidFreepointers( );
unsigned long SgTypeDouble_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeLongLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeLongLong* SgTypeLongLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeLongLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeLongLong* SgTypeLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeLongLong* SgTypeLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeLongLong_clearMemoryPool ( );
void SgTypeLongLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeLongLong_initializeStorageClassArray( SgTypeLongLongStorageClass *storageArray );
void SgTypeLongLong_resetValidFreepointers( );
unsigned long SgTypeLongLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeSignedLongLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeSignedLongLong* SgTypeSignedLongLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeSignedLongLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeSignedLongLong* SgTypeSignedLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeSignedLongLong* SgTypeSignedLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeSignedLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeSignedLongLong_clearMemoryPool ( );
void SgTypeSignedLongLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeSignedLongLong_initializeStorageClassArray( SgTypeSignedLongLongStorageClass *storageArray );
void SgTypeSignedLongLong_resetValidFreepointers( );
unsigned long SgTypeSignedLongLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeUnsignedLongLong_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeUnsignedLongLong_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeUnsignedLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeUnsignedLongLong_clearMemoryPool ( );
void SgTypeUnsignedLongLong_extendMemoryPoolForFileIO ( );
unsigned long SgTypeUnsignedLongLong_initializeStorageClassArray( SgTypeUnsignedLongLongStorageClass *storageArray );
void SgTypeUnsignedLongLong_resetValidFreepointers( );
unsigned long SgTypeUnsignedLongLong_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeLongDouble_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeLongDouble* SgTypeLongDouble_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeLongDouble_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeLongDouble* SgTypeLongDouble_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeLongDouble* SgTypeLongDouble_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeLongDouble_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeLongDouble_clearMemoryPool ( );
void SgTypeLongDouble_extendMemoryPoolForFileIO ( );
unsigned long SgTypeLongDouble_initializeStorageClassArray( SgTypeLongDoubleStorageClass *storageArray );
void SgTypeLongDouble_resetValidFreepointers( );
unsigned long SgTypeLongDouble_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeString_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeString* SgTypeString_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeString_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeString* SgTypeString_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeString* SgTypeString_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeString_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeString_clearMemoryPool ( );
void SgTypeString_extendMemoryPoolForFileIO ( );
unsigned long SgTypeString_initializeStorageClassArray( SgTypeStringStorageClass *storageArray );
void SgTypeString_resetValidFreepointers( );
unsigned long SgTypeString_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeBool_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeBool* SgTypeBool_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeBool_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeBool* SgTypeBool_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeBool* SgTypeBool_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeBool_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeBool_clearMemoryPool ( );
void SgTypeBool_extendMemoryPoolForFileIO ( );
unsigned long SgTypeBool_initializeStorageClassArray( SgTypeBoolStorageClass *storageArray );
void SgTypeBool_resetValidFreepointers( );
unsigned long SgTypeBool_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgPointerType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgPointerType* SgPointerType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgPointerType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgPointerType* SgPointerType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgPointerType* SgPointerType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgPointerType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgPointerType_clearMemoryPool ( );
void SgPointerType_extendMemoryPoolForFileIO ( );
unsigned long SgPointerType_initializeStorageClassArray( SgPointerTypeStorageClass *storageArray );
void SgPointerType_resetValidFreepointers( );
unsigned long SgPointerType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgPointerMemberType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgPointerMemberType* SgPointerMemberType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgPointerMemberType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgPointerMemberType* SgPointerMemberType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgPointerMemberType* SgPointerMemberType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgPointerMemberType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgPointerMemberType_clearMemoryPool ( );
void SgPointerMemberType_extendMemoryPoolForFileIO ( );
unsigned long SgPointerMemberType_initializeStorageClassArray( SgPointerMemberTypeStorageClass *storageArray );
void SgPointerMemberType_resetValidFreepointers( );
unsigned long SgPointerMemberType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgReferenceType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgReferenceType* SgReferenceType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgReferenceType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgReferenceType* SgReferenceType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgReferenceType* SgReferenceType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgReferenceType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgReferenceType_clearMemoryPool ( );
void SgReferenceType_extendMemoryPoolForFileIO ( );
unsigned long SgReferenceType_initializeStorageClassArray( SgReferenceTypeStorageClass *storageArray );
void SgReferenceType_resetValidFreepointers( );
unsigned long SgReferenceType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgNamedType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgNamedType* SgNamedType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgNamedType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgNamedType* SgNamedType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgNamedType* SgNamedType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgNamedType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgNamedType_clearMemoryPool ( );
void SgNamedType_extendMemoryPoolForFileIO ( );
unsigned long SgNamedType_initializeStorageClassArray( SgNamedTypeStorageClass *storageArray );
void SgNamedType_resetValidFreepointers( );
unsigned long SgNamedType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgClassType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgClassType* SgClassType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgClassType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgClassType* SgClassType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgClassType* SgClassType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgClassType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgClassType_clearMemoryPool ( );
void SgClassType_extendMemoryPoolForFileIO ( );
unsigned long SgClassType_initializeStorageClassArray( SgClassTypeStorageClass *storageArray );
void SgClassType_resetValidFreepointers( );
unsigned long SgClassType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgJavaParameterizedType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgJavaParameterizedType* SgJavaParameterizedType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgJavaParameterizedType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgJavaParameterizedType* SgJavaParameterizedType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgJavaParameterizedType* SgJavaParameterizedType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgJavaParameterizedType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgJavaParameterizedType_clearMemoryPool ( );
void SgJavaParameterizedType_extendMemoryPoolForFileIO ( );
unsigned long SgJavaParameterizedType_initializeStorageClassArray( SgJavaParameterizedTypeStorageClass *storageArray );
void SgJavaParameterizedType_resetValidFreepointers( );
unsigned long SgJavaParameterizedType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgEnumType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgEnumType* SgEnumType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgEnumType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgEnumType* SgEnumType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgEnumType* SgEnumType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgEnumType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgEnumType_clearMemoryPool ( );
void SgEnumType_extendMemoryPoolForFileIO ( );
unsigned long SgEnumType_initializeStorageClassArray( SgEnumTypeStorageClass *storageArray );
void SgEnumType_resetValidFreepointers( );
unsigned long SgEnumType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypedefType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypedefType* SgTypedefType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypedefType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypedefType* SgTypedefType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypedefType* SgTypedefType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypedefType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypedefType_clearMemoryPool ( );
void SgTypedefType_extendMemoryPoolForFileIO ( );
unsigned long SgTypedefType_initializeStorageClassArray( SgTypedefTypeStorageClass *storageArray );
void SgTypedefType_resetValidFreepointers( );
unsigned long SgTypedefType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgModifierType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgModifierType* SgModifierType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgModifierType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgModifierType* SgModifierType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgModifierType* SgModifierType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgModifierType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgModifierType_clearMemoryPool ( );
void SgModifierType_extendMemoryPoolForFileIO ( );
unsigned long SgModifierType_initializeStorageClassArray( SgModifierTypeStorageClass *storageArray );
void SgModifierType_resetValidFreepointers( );
unsigned long SgModifierType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgFunctionType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgFunctionType* SgFunctionType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgFunctionType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgFunctionType* SgFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgFunctionType* SgFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgFunctionType_clearMemoryPool ( );
void SgFunctionType_extendMemoryPoolForFileIO ( );
unsigned long SgFunctionType_initializeStorageClassArray( SgFunctionTypeStorageClass *storageArray );
void SgFunctionType_resetValidFreepointers( );
unsigned long SgFunctionType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgMemberFunctionType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgMemberFunctionType* SgMemberFunctionType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgMemberFunctionType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgMemberFunctionType* SgMemberFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgMemberFunctionType* SgMemberFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgMemberFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgMemberFunctionType_clearMemoryPool ( );
void SgMemberFunctionType_extendMemoryPoolForFileIO ( );
unsigned long SgMemberFunctionType_initializeStorageClassArray( SgMemberFunctionTypeStorageClass *storageArray );
void SgMemberFunctionType_resetValidFreepointers( );
unsigned long SgMemberFunctionType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgPartialFunctionType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgPartialFunctionType* SgPartialFunctionType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgPartialFunctionType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgPartialFunctionType* SgPartialFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgPartialFunctionType* SgPartialFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgPartialFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgPartialFunctionType_clearMemoryPool ( );
void SgPartialFunctionType_extendMemoryPoolForFileIO ( );
unsigned long SgPartialFunctionType_initializeStorageClassArray( SgPartialFunctionTypeStorageClass *storageArray );
void SgPartialFunctionType_resetValidFreepointers( );
unsigned long SgPartialFunctionType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgPartialFunctionModifierType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgPartialFunctionModifierType* SgPartialFunctionModifierType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgPartialFunctionModifierType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgPartialFunctionModifierType* SgPartialFunctionModifierType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgPartialFunctionModifierType* SgPartialFunctionModifierType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgPartialFunctionModifierType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgPartialFunctionModifierType_clearMemoryPool ( );
void SgPartialFunctionModifierType_extendMemoryPoolForFileIO ( );
unsigned long SgPartialFunctionModifierType_initializeStorageClassArray( SgPartialFunctionModifierTypeStorageClass *storageArray );
void SgPartialFunctionModifierType_resetValidFreepointers( );
unsigned long SgPartialFunctionModifierType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgArrayType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgArrayType* SgArrayType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgArrayType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgArrayType* SgArrayType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgArrayType* SgArrayType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgArrayType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgArrayType_clearMemoryPool ( );
void SgArrayType_extendMemoryPoolForFileIO ( );
unsigned long SgArrayType_initializeStorageClassArray( SgArrayTypeStorageClass *storageArray );
void SgArrayType_resetValidFreepointers( );
unsigned long SgArrayType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeEllipse_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeEllipse* SgTypeEllipse_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeEllipse_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeEllipse* SgTypeEllipse_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeEllipse* SgTypeEllipse_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeEllipse_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeEllipse_clearMemoryPool ( );
void SgTypeEllipse_extendMemoryPoolForFileIO ( );
unsigned long SgTypeEllipse_initializeStorageClassArray( SgTypeEllipseStorageClass *storageArray );
void SgTypeEllipse_resetValidFreepointers( );
unsigned long SgTypeEllipse_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTemplateType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTemplateType* SgTemplateType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTemplateType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTemplateType* SgTemplateType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTemplateType* SgTemplateType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTemplateType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTemplateType_clearMemoryPool ( );
void SgTemplateType_extendMemoryPoolForFileIO ( );
unsigned long SgTemplateType_initializeStorageClassArray( SgTemplateTypeStorageClass *storageArray );
void SgTemplateType_resetValidFreepointers( );
unsigned long SgTemplateType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgQualifiedNameType_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgQualifiedNameType* SgQualifiedNameType_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgQualifiedNameType_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgQualifiedNameType* SgQualifiedNameType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgQualifiedNameType* SgQualifiedNameType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgQualifiedNameType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgQualifiedNameType_clearMemoryPool ( );
void SgQualifiedNameType_extendMemoryPoolForFileIO ( );
unsigned long SgQualifiedNameType_initializeStorageClassArray( SgQualifiedNameTypeStorageClass *storageArray );
void SgQualifiedNameType_resetValidFreepointers( );
unsigned long SgQualifiedNameType_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeComplex_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeComplex* SgTypeComplex_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeComplex_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeComplex* SgTypeComplex_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeComplex* SgTypeComplex_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeComplex_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeComplex_clearMemoryPool ( );
void SgTypeComplex_extendMemoryPoolForFileIO ( );
unsigned long SgTypeComplex_initializeStorageClassArray( SgTypeComplexStorageClass *storageArray );
void SgTypeComplex_resetValidFreepointers( );
unsigned long SgTypeComplex_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeImaginary_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeImaginary* SgTypeImaginary_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeImaginary_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeImaginary* SgTypeImaginary_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeImaginary* SgTypeImaginary_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeImaginary_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeImaginary_clearMemoryPool ( );
void SgTypeImaginary_extendMemoryPoolForFileIO ( );
unsigned long SgTypeImaginary_initializeStorageClassArray( SgTypeImaginaryStorageClass *storageArray );
void SgTypeImaginary_resetValidFreepointers( );
unsigned long SgTypeImaginary_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeDefault_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeDefault* SgTypeDefault_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeDefault_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeDefault* SgTypeDefault_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeDefault* SgTypeDefault_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeDefault_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeDefault_clearMemoryPool ( );
void SgTypeDefault_extendMemoryPoolForFileIO ( );
unsigned long SgTypeDefault_initializeStorageClassArray( SgTypeDefaultStorageClass *storageArray );
void SgTypeDefault_resetValidFreepointers( );
unsigned long SgTypeDefault_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeCAFTeam_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeCAFTeam* SgTypeCAFTeam_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeCAFTeam_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeCAFTeam* SgTypeCAFTeam_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeCAFTeam* SgTypeCAFTeam_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeCAFTeam_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeCAFTeam_clearMemoryPool ( );
void SgTypeCAFTeam_extendMemoryPoolForFileIO ( );
unsigned long SgTypeCAFTeam_initializeStorageClassArray( SgTypeCAFTeamStorageClass *storageArray );
void SgTypeCAFTeam_resetValidFreepointers( );
unsigned long SgTypeCAFTeam_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeCrayPointer_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeCrayPointer* SgTypeCrayPointer_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeCrayPointer_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeCrayPointer* SgTypeCrayPointer_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeCrayPointer* SgTypeCrayPointer_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeCrayPointer_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeCrayPointer_clearMemoryPool ( );
void SgTypeCrayPointer_extendMemoryPoolForFileIO ( );
unsigned long SgTypeCrayPointer_initializeStorageClassArray( SgTypeCrayPointerStorageClass *storageArray );
void SgTypeCrayPointer_resetValidFreepointers( );
unsigned long SgTypeCrayPointer_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgTypeLabel_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgTypeLabel* SgTypeLabel_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgTypeLabel_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgTypeLabel* SgTypeLabel_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgTypeLabel* SgTypeLabel_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgTypeLabel_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgTypeLabel_clearMemoryPool ( );
void SgTypeLabel_extendMemoryPoolForFileIO ( );
unsigned long SgTypeLabel_initializeStorageClassArray( SgTypeLabelStorageClass *storageArray );
void SgTypeLabel_resetValidFreepointers( );
unsigned long SgTypeLabel_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgLocatedNode_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgLocatedNode* SgLocatedNode_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgLocatedNode_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgLocatedNode* SgLocatedNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgLocatedNode* SgLocatedNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgLocatedNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgLocatedNode_clearMemoryPool ( );
void SgLocatedNode_extendMemoryPoolForFileIO ( );
unsigned long SgLocatedNode_initializeStorageClassArray( SgLocatedNodeStorageClass *storageArray );
void SgLocatedNode_resetValidFreepointers( );
unsigned long SgLocatedNode_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgLocatedNodeSupport_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgLocatedNodeSupport* SgLocatedNodeSupport_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgLocatedNodeSupport_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgLocatedNodeSupport* SgLocatedNodeSupport_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgLocatedNodeSupport* SgLocatedNodeSupport_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgLocatedNodeSupport_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgLocatedNodeSupport_clearMemoryPool ( );
void SgLocatedNodeSupport_extendMemoryPoolForFileIO ( );
unsigned long SgLocatedNodeSupport_initializeStorageClassArray( SgLocatedNodeSupportStorageClass *storageArray );
void SgLocatedNodeSupport_resetValidFreepointers( );
unsigned long SgLocatedNodeSupport_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */

#include <semaphore.h>
// DQ (9/21/2005): Static variables supporting memory pools
extern int SgCommonBlockObject_CLASS_ALLOCATION_POOL_SIZE;        // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;

extern SgCommonBlockObject* SgCommonBlockObject_Current_Link;              // = NULL;

// DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
// This is was one of the things on the todo list (above).

extern std::vector < unsigned char* > SgCommonBlockObject_Memory_Block_List;
/* */

// DQ (4/6/2006): Newer code from Jochen
// Methods to find the pointer to a global and local index
SgCommonBlockObject* SgCommonBlockObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
SgCommonBlockObject* SgCommonBlockObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;

// Methods for computing the total size of the memory pool. It actually returns the
// size of the whole blocks allocated, no matter they contain valid pointers or not
unsigned long SgCommonBlockObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
void SgCommonBlockObject_clearMemoryPool ( );
void SgCommonBlockObject_extendMemoryPoolForFileIO ( );
unsigned long SgCommonBlockObject_initializeStorageClassArray( SgCommonBlockObjectStorageClass *storageArray );
void SgCommonBlockObject_resetValidFreepointers( );
unsigned long SgCommonBlockObject_getNumberOfLastValidPointer();


/* #line 1 "/export/tmp.hudson-rose/hudson/workspace/a90-ROSE-daily-release/label/amd64-linux/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */