ROSE  0.9.9.139
Cxx_GrammarMemoryPoolSupport.h
1 // MACHINE GENERATED SOURCE FILE --- DO NOT MODIFY! (Grammar.C)
2 
3 
4 // generated file
5 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6 
7 #include <semaphore.h>
8 // DQ (9/21/2005): Static variables supporting memory pools
15 extern int SgNode_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
16 
21 extern SgNode* SgNode_Current_Link; // = NULL;
22 
23 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
24 // This is was one of the things on the todo list (above).
25 
30 extern std::vector < unsigned char* > SgNode_Memory_Block_List;
31 /* */
32 
33 // DQ (4/6/2006): Newer code from Jochen
34 // Methods to find the pointer to a global and local index
35 SgNode* SgNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
36 SgNode* SgNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
37 
38 // Methods for computing the total size of the memory pool. It actually returns the
39 // size of the whole blocks allocated, no matter they contain valid pointers or not
40 unsigned long SgNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
41 void SgNode_clearMemoryPool ( );
42 void SgNode_extendMemoryPoolForFileIO ( );
43 unsigned long SgNode_initializeStorageClassArray( SgNodeStorageClass *storageArray );
44 void SgNode_resetValidFreepointers( );
45 unsigned long SgNode_getNumberOfLastValidPointer();
46 
47 
48 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
49 
50 #include <semaphore.h>
51 // DQ (9/21/2005): Static variables supporting memory pools
58 extern int SgSupport_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
59 
64 extern SgSupport* SgSupport_Current_Link; // = NULL;
65 
66 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
67 // This is was one of the things on the todo list (above).
68 
73 extern std::vector < unsigned char* > SgSupport_Memory_Block_List;
74 /* */
75 
76 // DQ (4/6/2006): Newer code from Jochen
77 // Methods to find the pointer to a global and local index
78 SgSupport* SgSupport_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
79 SgSupport* SgSupport_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
80 
81 // Methods for computing the total size of the memory pool. It actually returns the
82 // size of the whole blocks allocated, no matter they contain valid pointers or not
83 unsigned long SgSupport_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
84 void SgSupport_clearMemoryPool ( );
85 void SgSupport_extendMemoryPoolForFileIO ( );
86 unsigned long SgSupport_initializeStorageClassArray( SgSupportStorageClass *storageArray );
87 void SgSupport_resetValidFreepointers( );
88 unsigned long SgSupport_getNumberOfLastValidPointer();
89 
90 
91 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
92 
93 #include <semaphore.h>
94 // DQ (9/21/2005): Static variables supporting memory pools
101 extern int SgModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
102 
107 extern SgModifier* SgModifier_Current_Link; // = NULL;
108 
109 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
110 // This is was one of the things on the todo list (above).
111 
116 extern std::vector < unsigned char* > SgModifier_Memory_Block_List;
117 /* */
118 
119 // DQ (4/6/2006): Newer code from Jochen
120 // Methods to find the pointer to a global and local index
121 SgModifier* SgModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
122 SgModifier* SgModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
123 
124 // Methods for computing the total size of the memory pool. It actually returns the
125 // size of the whole blocks allocated, no matter they contain valid pointers or not
126 unsigned long SgModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
127 void SgModifier_clearMemoryPool ( );
128 void SgModifier_extendMemoryPoolForFileIO ( );
129 unsigned long SgModifier_initializeStorageClassArray( SgModifierStorageClass *storageArray );
130 void SgModifier_resetValidFreepointers( );
131 unsigned long SgModifier_getNumberOfLastValidPointer();
132 
133 
134 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
135 
136 #include <semaphore.h>
137 // DQ (9/21/2005): Static variables supporting memory pools
144 extern int SgModifierNodes_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
145 
150 extern SgModifierNodes* SgModifierNodes_Current_Link; // = NULL;
151 
152 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
153 // This is was one of the things on the todo list (above).
154 
159 extern std::vector < unsigned char* > SgModifierNodes_Memory_Block_List;
160 /* */
161 
162 // DQ (4/6/2006): Newer code from Jochen
163 // Methods to find the pointer to a global and local index
164 SgModifierNodes* SgModifierNodes_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
165 SgModifierNodes* SgModifierNodes_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
166 
167 // Methods for computing the total size of the memory pool. It actually returns the
168 // size of the whole blocks allocated, no matter they contain valid pointers or not
169 unsigned long SgModifierNodes_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
170 void SgModifierNodes_clearMemoryPool ( );
171 void SgModifierNodes_extendMemoryPoolForFileIO ( );
172 unsigned long SgModifierNodes_initializeStorageClassArray( SgModifierNodesStorageClass *storageArray );
173 void SgModifierNodes_resetValidFreepointers( );
174 unsigned long SgModifierNodes_getNumberOfLastValidPointer();
175 
176 
177 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
178 
179 #include <semaphore.h>
180 // DQ (9/21/2005): Static variables supporting memory pools
187 extern int SgConstVolatileModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
188 
193 extern SgConstVolatileModifier* SgConstVolatileModifier_Current_Link; // = NULL;
194 
195 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
196 // This is was one of the things on the todo list (above).
197 
202 extern std::vector < unsigned char* > SgConstVolatileModifier_Memory_Block_List;
203 /* */
204 
205 // DQ (4/6/2006): Newer code from Jochen
206 // Methods to find the pointer to a global and local index
207 SgConstVolatileModifier* SgConstVolatileModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
208 SgConstVolatileModifier* SgConstVolatileModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
209 
210 // Methods for computing the total size of the memory pool. It actually returns the
211 // size of the whole blocks allocated, no matter they contain valid pointers or not
212 unsigned long SgConstVolatileModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
213 void SgConstVolatileModifier_clearMemoryPool ( );
214 void SgConstVolatileModifier_extendMemoryPoolForFileIO ( );
215 unsigned long SgConstVolatileModifier_initializeStorageClassArray( SgConstVolatileModifierStorageClass *storageArray );
216 void SgConstVolatileModifier_resetValidFreepointers( );
217 unsigned long SgConstVolatileModifier_getNumberOfLastValidPointer();
218 
219 
220 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
221 
222 #include <semaphore.h>
223 // DQ (9/21/2005): Static variables supporting memory pools
230 extern int SgStorageModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
231 
236 extern SgStorageModifier* SgStorageModifier_Current_Link; // = NULL;
237 
238 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
239 // This is was one of the things on the todo list (above).
240 
245 extern std::vector < unsigned char* > SgStorageModifier_Memory_Block_List;
246 /* */
247 
248 // DQ (4/6/2006): Newer code from Jochen
249 // Methods to find the pointer to a global and local index
250 SgStorageModifier* SgStorageModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
251 SgStorageModifier* SgStorageModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
252 
253 // Methods for computing the total size of the memory pool. It actually returns the
254 // size of the whole blocks allocated, no matter they contain valid pointers or not
255 unsigned long SgStorageModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
256 void SgStorageModifier_clearMemoryPool ( );
257 void SgStorageModifier_extendMemoryPoolForFileIO ( );
258 unsigned long SgStorageModifier_initializeStorageClassArray( SgStorageModifierStorageClass *storageArray );
259 void SgStorageModifier_resetValidFreepointers( );
260 unsigned long SgStorageModifier_getNumberOfLastValidPointer();
261 
262 
263 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
264 
265 #include <semaphore.h>
266 // DQ (9/21/2005): Static variables supporting memory pools
273 extern int SgAccessModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
274 
279 extern SgAccessModifier* SgAccessModifier_Current_Link; // = NULL;
280 
281 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
282 // This is was one of the things on the todo list (above).
283 
288 extern std::vector < unsigned char* > SgAccessModifier_Memory_Block_List;
289 /* */
290 
291 // DQ (4/6/2006): Newer code from Jochen
292 // Methods to find the pointer to a global and local index
293 SgAccessModifier* SgAccessModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
294 SgAccessModifier* SgAccessModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
295 
296 // Methods for computing the total size of the memory pool. It actually returns the
297 // size of the whole blocks allocated, no matter they contain valid pointers or not
298 unsigned long SgAccessModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
299 void SgAccessModifier_clearMemoryPool ( );
300 void SgAccessModifier_extendMemoryPoolForFileIO ( );
301 unsigned long SgAccessModifier_initializeStorageClassArray( SgAccessModifierStorageClass *storageArray );
302 void SgAccessModifier_resetValidFreepointers( );
303 unsigned long SgAccessModifier_getNumberOfLastValidPointer();
304 
305 
306 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
307 
308 #include <semaphore.h>
309 // DQ (9/21/2005): Static variables supporting memory pools
316 extern int SgFunctionModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
317 
322 extern SgFunctionModifier* SgFunctionModifier_Current_Link; // = NULL;
323 
324 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
325 // This is was one of the things on the todo list (above).
326 
331 extern std::vector < unsigned char* > SgFunctionModifier_Memory_Block_List;
332 /* */
333 
334 // DQ (4/6/2006): Newer code from Jochen
335 // Methods to find the pointer to a global and local index
336 SgFunctionModifier* SgFunctionModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
337 SgFunctionModifier* SgFunctionModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
338 
339 // Methods for computing the total size of the memory pool. It actually returns the
340 // size of the whole blocks allocated, no matter they contain valid pointers or not
341 unsigned long SgFunctionModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
342 void SgFunctionModifier_clearMemoryPool ( );
343 void SgFunctionModifier_extendMemoryPoolForFileIO ( );
344 unsigned long SgFunctionModifier_initializeStorageClassArray( SgFunctionModifierStorageClass *storageArray );
345 void SgFunctionModifier_resetValidFreepointers( );
346 unsigned long SgFunctionModifier_getNumberOfLastValidPointer();
347 
348 
349 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
350 
351 #include <semaphore.h>
352 // DQ (9/21/2005): Static variables supporting memory pools
359 extern int SgUPC_AccessModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
360 
365 extern SgUPC_AccessModifier* SgUPC_AccessModifier_Current_Link; // = NULL;
366 
367 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
368 // This is was one of the things on the todo list (above).
369 
374 extern std::vector < unsigned char* > SgUPC_AccessModifier_Memory_Block_List;
375 /* */
376 
377 // DQ (4/6/2006): Newer code from Jochen
378 // Methods to find the pointer to a global and local index
379 SgUPC_AccessModifier* SgUPC_AccessModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
380 SgUPC_AccessModifier* SgUPC_AccessModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
381 
382 // Methods for computing the total size of the memory pool. It actually returns the
383 // size of the whole blocks allocated, no matter they contain valid pointers or not
384 unsigned long SgUPC_AccessModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
385 void SgUPC_AccessModifier_clearMemoryPool ( );
386 void SgUPC_AccessModifier_extendMemoryPoolForFileIO ( );
387 unsigned long SgUPC_AccessModifier_initializeStorageClassArray( SgUPC_AccessModifierStorageClass *storageArray );
388 void SgUPC_AccessModifier_resetValidFreepointers( );
389 unsigned long SgUPC_AccessModifier_getNumberOfLastValidPointer();
390 
391 
392 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
393 
394 #include <semaphore.h>
395 // DQ (9/21/2005): Static variables supporting memory pools
402 extern int SgSpecialFunctionModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
403 
408 extern SgSpecialFunctionModifier* SgSpecialFunctionModifier_Current_Link; // = NULL;
409 
410 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
411 // This is was one of the things on the todo list (above).
412 
417 extern std::vector < unsigned char* > SgSpecialFunctionModifier_Memory_Block_List;
418 /* */
419 
420 // DQ (4/6/2006): Newer code from Jochen
421 // Methods to find the pointer to a global and local index
422 SgSpecialFunctionModifier* SgSpecialFunctionModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
423 SgSpecialFunctionModifier* SgSpecialFunctionModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
424 
425 // Methods for computing the total size of the memory pool. It actually returns the
426 // size of the whole blocks allocated, no matter they contain valid pointers or not
427 unsigned long SgSpecialFunctionModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
428 void SgSpecialFunctionModifier_clearMemoryPool ( );
429 void SgSpecialFunctionModifier_extendMemoryPoolForFileIO ( );
430 unsigned long SgSpecialFunctionModifier_initializeStorageClassArray( SgSpecialFunctionModifierStorageClass *storageArray );
431 void SgSpecialFunctionModifier_resetValidFreepointers( );
432 unsigned long SgSpecialFunctionModifier_getNumberOfLastValidPointer();
433 
434 
435 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
436 
437 #include <semaphore.h>
438 // DQ (9/21/2005): Static variables supporting memory pools
445 extern int SgElaboratedTypeModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
446 
451 extern SgElaboratedTypeModifier* SgElaboratedTypeModifier_Current_Link; // = NULL;
452 
453 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
454 // This is was one of the things on the todo list (above).
455 
460 extern std::vector < unsigned char* > SgElaboratedTypeModifier_Memory_Block_List;
461 /* */
462 
463 // DQ (4/6/2006): Newer code from Jochen
464 // Methods to find the pointer to a global and local index
465 SgElaboratedTypeModifier* SgElaboratedTypeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
466 SgElaboratedTypeModifier* SgElaboratedTypeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
467 
468 // Methods for computing the total size of the memory pool. It actually returns the
469 // size of the whole blocks allocated, no matter they contain valid pointers or not
470 unsigned long SgElaboratedTypeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
471 void SgElaboratedTypeModifier_clearMemoryPool ( );
472 void SgElaboratedTypeModifier_extendMemoryPoolForFileIO ( );
473 unsigned long SgElaboratedTypeModifier_initializeStorageClassArray( SgElaboratedTypeModifierStorageClass *storageArray );
474 void SgElaboratedTypeModifier_resetValidFreepointers( );
475 unsigned long SgElaboratedTypeModifier_getNumberOfLastValidPointer();
476 
477 
478 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
479 
480 #include <semaphore.h>
481 // DQ (9/21/2005): Static variables supporting memory pools
488 extern int SgLinkageModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
489 
494 extern SgLinkageModifier* SgLinkageModifier_Current_Link; // = NULL;
495 
496 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
497 // This is was one of the things on the todo list (above).
498 
503 extern std::vector < unsigned char* > SgLinkageModifier_Memory_Block_List;
504 /* */
505 
506 // DQ (4/6/2006): Newer code from Jochen
507 // Methods to find the pointer to a global and local index
508 SgLinkageModifier* SgLinkageModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
509 SgLinkageModifier* SgLinkageModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
510 
511 // Methods for computing the total size of the memory pool. It actually returns the
512 // size of the whole blocks allocated, no matter they contain valid pointers or not
513 unsigned long SgLinkageModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
514 void SgLinkageModifier_clearMemoryPool ( );
515 void SgLinkageModifier_extendMemoryPoolForFileIO ( );
516 unsigned long SgLinkageModifier_initializeStorageClassArray( SgLinkageModifierStorageClass *storageArray );
517 void SgLinkageModifier_resetValidFreepointers( );
518 unsigned long SgLinkageModifier_getNumberOfLastValidPointer();
519 
520 
521 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
522 
523 #include <semaphore.h>
524 // DQ (9/21/2005): Static variables supporting memory pools
531 extern int SgBaseClassModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
532 
537 extern SgBaseClassModifier* SgBaseClassModifier_Current_Link; // = NULL;
538 
539 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
540 // This is was one of the things on the todo list (above).
541 
546 extern std::vector < unsigned char* > SgBaseClassModifier_Memory_Block_List;
547 /* */
548 
549 // DQ (4/6/2006): Newer code from Jochen
550 // Methods to find the pointer to a global and local index
551 SgBaseClassModifier* SgBaseClassModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
552 SgBaseClassModifier* SgBaseClassModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
553 
554 // Methods for computing the total size of the memory pool. It actually returns the
555 // size of the whole blocks allocated, no matter they contain valid pointers or not
556 unsigned long SgBaseClassModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
557 void SgBaseClassModifier_clearMemoryPool ( );
558 void SgBaseClassModifier_extendMemoryPoolForFileIO ( );
559 unsigned long SgBaseClassModifier_initializeStorageClassArray( SgBaseClassModifierStorageClass *storageArray );
560 void SgBaseClassModifier_resetValidFreepointers( );
561 unsigned long SgBaseClassModifier_getNumberOfLastValidPointer();
562 
563 
564 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
565 
566 #include <semaphore.h>
567 // DQ (9/21/2005): Static variables supporting memory pools
574 extern int SgTypeModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
575 
580 extern SgTypeModifier* SgTypeModifier_Current_Link; // = NULL;
581 
582 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
583 // This is was one of the things on the todo list (above).
584 
589 extern std::vector < unsigned char* > SgTypeModifier_Memory_Block_List;
590 /* */
591 
592 // DQ (4/6/2006): Newer code from Jochen
593 // Methods to find the pointer to a global and local index
594 SgTypeModifier* SgTypeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
595 SgTypeModifier* SgTypeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
596 
597 // Methods for computing the total size of the memory pool. It actually returns the
598 // size of the whole blocks allocated, no matter they contain valid pointers or not
599 unsigned long SgTypeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
600 void SgTypeModifier_clearMemoryPool ( );
601 void SgTypeModifier_extendMemoryPoolForFileIO ( );
602 unsigned long SgTypeModifier_initializeStorageClassArray( SgTypeModifierStorageClass *storageArray );
603 void SgTypeModifier_resetValidFreepointers( );
604 unsigned long SgTypeModifier_getNumberOfLastValidPointer();
605 
606 
607 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
608 
609 #include <semaphore.h>
610 // DQ (9/21/2005): Static variables supporting memory pools
617 extern int SgDeclarationModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
618 
623 extern SgDeclarationModifier* SgDeclarationModifier_Current_Link; // = NULL;
624 
625 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
626 // This is was one of the things on the todo list (above).
627 
632 extern std::vector < unsigned char* > SgDeclarationModifier_Memory_Block_List;
633 /* */
634 
635 // DQ (4/6/2006): Newer code from Jochen
636 // Methods to find the pointer to a global and local index
637 SgDeclarationModifier* SgDeclarationModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
638 SgDeclarationModifier* SgDeclarationModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
639 
640 // Methods for computing the total size of the memory pool. It actually returns the
641 // size of the whole blocks allocated, no matter they contain valid pointers or not
642 unsigned long SgDeclarationModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
643 void SgDeclarationModifier_clearMemoryPool ( );
644 void SgDeclarationModifier_extendMemoryPoolForFileIO ( );
645 unsigned long SgDeclarationModifier_initializeStorageClassArray( SgDeclarationModifierStorageClass *storageArray );
646 void SgDeclarationModifier_resetValidFreepointers( );
647 unsigned long SgDeclarationModifier_getNumberOfLastValidPointer();
648 
649 
650 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
651 
652 #include <semaphore.h>
653 // DQ (9/21/2005): Static variables supporting memory pools
660 extern int SgOpenclAccessModeModifier_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
661 
666 extern SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_Current_Link; // = NULL;
667 
668 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
669 // This is was one of the things on the todo list (above).
670 
675 extern std::vector < unsigned char* > SgOpenclAccessModeModifier_Memory_Block_List;
676 /* */
677 
678 // DQ (4/6/2006): Newer code from Jochen
679 // Methods to find the pointer to a global and local index
680 SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
681 SgOpenclAccessModeModifier* SgOpenclAccessModeModifier_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
682 
683 // Methods for computing the total size of the memory pool. It actually returns the
684 // size of the whole blocks allocated, no matter they contain valid pointers or not
685 unsigned long SgOpenclAccessModeModifier_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
686 void SgOpenclAccessModeModifier_clearMemoryPool ( );
687 void SgOpenclAccessModeModifier_extendMemoryPoolForFileIO ( );
688 unsigned long SgOpenclAccessModeModifier_initializeStorageClassArray( SgOpenclAccessModeModifierStorageClass *storageArray );
689 void SgOpenclAccessModeModifier_resetValidFreepointers( );
690 unsigned long SgOpenclAccessModeModifier_getNumberOfLastValidPointer();
691 
692 
693 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
694 
695 #include <semaphore.h>
696 // DQ (9/21/2005): Static variables supporting memory pools
703 extern int SgName_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
704 
709 extern SgName* SgName_Current_Link; // = NULL;
710 
711 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
712 // This is was one of the things on the todo list (above).
713 
718 extern std::vector < unsigned char* > SgName_Memory_Block_List;
719 /* */
720 
721 // DQ (4/6/2006): Newer code from Jochen
722 // Methods to find the pointer to a global and local index
723 SgName* SgName_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
724 SgName* SgName_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
725 
726 // Methods for computing the total size of the memory pool. It actually returns the
727 // size of the whole blocks allocated, no matter they contain valid pointers or not
728 unsigned long SgName_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
729 void SgName_clearMemoryPool ( );
730 void SgName_extendMemoryPoolForFileIO ( );
731 unsigned long SgName_initializeStorageClassArray( SgNameStorageClass *storageArray );
732 void SgName_resetValidFreepointers( );
733 unsigned long SgName_getNumberOfLastValidPointer();
734 
735 
736 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
737 
738 #include <semaphore.h>
739 // DQ (9/21/2005): Static variables supporting memory pools
746 extern int SgSymbolTable_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
747 
752 extern SgSymbolTable* SgSymbolTable_Current_Link; // = NULL;
753 
754 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
755 // This is was one of the things on the todo list (above).
756 
761 extern std::vector < unsigned char* > SgSymbolTable_Memory_Block_List;
762 /* */
763 
764 // DQ (4/6/2006): Newer code from Jochen
765 // Methods to find the pointer to a global and local index
766 SgSymbolTable* SgSymbolTable_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
767 SgSymbolTable* SgSymbolTable_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
768 
769 // Methods for computing the total size of the memory pool. It actually returns the
770 // size of the whole blocks allocated, no matter they contain valid pointers or not
771 unsigned long SgSymbolTable_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
772 void SgSymbolTable_clearMemoryPool ( );
773 void SgSymbolTable_extendMemoryPoolForFileIO ( );
774 unsigned long SgSymbolTable_initializeStorageClassArray( SgSymbolTableStorageClass *storageArray );
775 void SgSymbolTable_resetValidFreepointers( );
776 unsigned long SgSymbolTable_getNumberOfLastValidPointer();
777 
778 
779 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
780 
781 #include <semaphore.h>
782 // DQ (9/21/2005): Static variables supporting memory pools
789 extern int SgAttribute_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
790 
795 extern SgAttribute* SgAttribute_Current_Link; // = NULL;
796 
797 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
798 // This is was one of the things on the todo list (above).
799 
804 extern std::vector < unsigned char* > SgAttribute_Memory_Block_List;
805 /* */
806 
807 // DQ (4/6/2006): Newer code from Jochen
808 // Methods to find the pointer to a global and local index
809 SgAttribute* SgAttribute_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
810 SgAttribute* SgAttribute_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
811 
812 // Methods for computing the total size of the memory pool. It actually returns the
813 // size of the whole blocks allocated, no matter they contain valid pointers or not
814 unsigned long SgAttribute_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
815 void SgAttribute_clearMemoryPool ( );
816 void SgAttribute_extendMemoryPoolForFileIO ( );
817 unsigned long SgAttribute_initializeStorageClassArray( SgAttributeStorageClass *storageArray );
818 void SgAttribute_resetValidFreepointers( );
819 unsigned long SgAttribute_getNumberOfLastValidPointer();
820 
821 
822 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
823 
824 #include <semaphore.h>
825 // DQ (9/21/2005): Static variables supporting memory pools
832 extern int SgPragma_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
833 
838 extern SgPragma* SgPragma_Current_Link; // = NULL;
839 
840 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
841 // This is was one of the things on the todo list (above).
842 
847 extern std::vector < unsigned char* > SgPragma_Memory_Block_List;
848 /* */
849 
850 // DQ (4/6/2006): Newer code from Jochen
851 // Methods to find the pointer to a global and local index
852 SgPragma* SgPragma_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
853 SgPragma* SgPragma_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
854 
855 // Methods for computing the total size of the memory pool. It actually returns the
856 // size of the whole blocks allocated, no matter they contain valid pointers or not
857 unsigned long SgPragma_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
858 void SgPragma_clearMemoryPool ( );
859 void SgPragma_extendMemoryPoolForFileIO ( );
860 unsigned long SgPragma_initializeStorageClassArray( SgPragmaStorageClass *storageArray );
861 void SgPragma_resetValidFreepointers( );
862 unsigned long SgPragma_getNumberOfLastValidPointer();
863 
864 
865 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
866 
867 #include <semaphore.h>
868 // DQ (9/21/2005): Static variables supporting memory pools
875 extern int SgBitAttribute_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
876 
881 extern SgBitAttribute* SgBitAttribute_Current_Link; // = NULL;
882 
883 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
884 // This is was one of the things on the todo list (above).
885 
890 extern std::vector < unsigned char* > SgBitAttribute_Memory_Block_List;
891 /* */
892 
893 // DQ (4/6/2006): Newer code from Jochen
894 // Methods to find the pointer to a global and local index
895 SgBitAttribute* SgBitAttribute_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
896 SgBitAttribute* SgBitAttribute_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
897 
898 // Methods for computing the total size of the memory pool. It actually returns the
899 // size of the whole blocks allocated, no matter they contain valid pointers or not
900 unsigned long SgBitAttribute_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
901 void SgBitAttribute_clearMemoryPool ( );
902 void SgBitAttribute_extendMemoryPoolForFileIO ( );
903 unsigned long SgBitAttribute_initializeStorageClassArray( SgBitAttributeStorageClass *storageArray );
904 void SgBitAttribute_resetValidFreepointers( );
905 unsigned long SgBitAttribute_getNumberOfLastValidPointer();
906 
907 
908 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
909 
910 #include <semaphore.h>
911 // DQ (9/21/2005): Static variables supporting memory pools
918 extern int SgFuncDecl_attr_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
919 
924 extern SgFuncDecl_attr* SgFuncDecl_attr_Current_Link; // = NULL;
925 
926 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
927 // This is was one of the things on the todo list (above).
928 
933 extern std::vector < unsigned char* > SgFuncDecl_attr_Memory_Block_List;
934 /* */
935 
936 // DQ (4/6/2006): Newer code from Jochen
937 // Methods to find the pointer to a global and local index
938 SgFuncDecl_attr* SgFuncDecl_attr_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
939 SgFuncDecl_attr* SgFuncDecl_attr_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
940 
941 // Methods for computing the total size of the memory pool. It actually returns the
942 // size of the whole blocks allocated, no matter they contain valid pointers or not
943 unsigned long SgFuncDecl_attr_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
944 void SgFuncDecl_attr_clearMemoryPool ( );
945 void SgFuncDecl_attr_extendMemoryPoolForFileIO ( );
946 unsigned long SgFuncDecl_attr_initializeStorageClassArray( SgFuncDecl_attrStorageClass *storageArray );
947 void SgFuncDecl_attr_resetValidFreepointers( );
948 unsigned long SgFuncDecl_attr_getNumberOfLastValidPointer();
949 
950 
951 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
952 
953 #include <semaphore.h>
954 // DQ (9/21/2005): Static variables supporting memory pools
961 extern int SgClassDecl_attr_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
962 
967 extern SgClassDecl_attr* SgClassDecl_attr_Current_Link; // = NULL;
968 
969 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
970 // This is was one of the things on the todo list (above).
971 
976 extern std::vector < unsigned char* > SgClassDecl_attr_Memory_Block_List;
977 /* */
978 
979 // DQ (4/6/2006): Newer code from Jochen
980 // Methods to find the pointer to a global and local index
981 SgClassDecl_attr* SgClassDecl_attr_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
982 SgClassDecl_attr* SgClassDecl_attr_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
983 
984 // Methods for computing the total size of the memory pool. It actually returns the
985 // size of the whole blocks allocated, no matter they contain valid pointers or not
986 unsigned long SgClassDecl_attr_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
987 void SgClassDecl_attr_clearMemoryPool ( );
988 void SgClassDecl_attr_extendMemoryPoolForFileIO ( );
989 unsigned long SgClassDecl_attr_initializeStorageClassArray( SgClassDecl_attrStorageClass *storageArray );
990 void SgClassDecl_attr_resetValidFreepointers( );
991 unsigned long SgClassDecl_attr_getNumberOfLastValidPointer();
992 
993 
994 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
995 
996 #include <semaphore.h>
997 // DQ (9/21/2005): Static variables supporting memory pools
1004 extern int Sg_File_Info_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1005 
1010 extern Sg_File_Info* Sg_File_Info_Current_Link; // = NULL;
1011 
1012 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1013 // This is was one of the things on the todo list (above).
1014 
1019 extern std::vector < unsigned char* > Sg_File_Info_Memory_Block_List;
1020 /* */
1021 
1022 // DQ (4/6/2006): Newer code from Jochen
1023 // Methods to find the pointer to a global and local index
1024 Sg_File_Info* Sg_File_Info_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1025 Sg_File_Info* Sg_File_Info_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1026 
1027 // Methods for computing the total size of the memory pool. It actually returns the
1028 // size of the whole blocks allocated, no matter they contain valid pointers or not
1029 unsigned long Sg_File_Info_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1030 void Sg_File_Info_clearMemoryPool ( );
1031 void Sg_File_Info_extendMemoryPoolForFileIO ( );
1032 unsigned long Sg_File_Info_initializeStorageClassArray( Sg_File_InfoStorageClass *storageArray );
1033 void Sg_File_Info_resetValidFreepointers( );
1034 unsigned long Sg_File_Info_getNumberOfLastValidPointer();
1035 
1036 
1037 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1038 
1039 #include <semaphore.h>
1040 // DQ (9/21/2005): Static variables supporting memory pools
1047 extern int SgFile_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1048 
1053 extern SgFile* SgFile_Current_Link; // = NULL;
1054 
1055 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1056 // This is was one of the things on the todo list (above).
1057 
1062 extern std::vector < unsigned char* > SgFile_Memory_Block_List;
1063 /* */
1064 
1065 // DQ (4/6/2006): Newer code from Jochen
1066 // Methods to find the pointer to a global and local index
1067 SgFile* SgFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1068 SgFile* SgFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1069 
1070 // Methods for computing the total size of the memory pool. It actually returns the
1071 // size of the whole blocks allocated, no matter they contain valid pointers or not
1072 unsigned long SgFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1073 void SgFile_clearMemoryPool ( );
1074 void SgFile_extendMemoryPoolForFileIO ( );
1075 unsigned long SgFile_initializeStorageClassArray( SgFileStorageClass *storageArray );
1076 void SgFile_resetValidFreepointers( );
1077 unsigned long SgFile_getNumberOfLastValidPointer();
1078 
1079 
1080 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1081 
1082 #include <semaphore.h>
1083 // DQ (9/21/2005): Static variables supporting memory pools
1090 extern int SgSourceFile_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1091 
1096 extern SgSourceFile* SgSourceFile_Current_Link; // = NULL;
1097 
1098 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1099 // This is was one of the things on the todo list (above).
1100 
1105 extern std::vector < unsigned char* > SgSourceFile_Memory_Block_List;
1106 /* */
1107 
1108 // DQ (4/6/2006): Newer code from Jochen
1109 // Methods to find the pointer to a global and local index
1110 SgSourceFile* SgSourceFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1111 SgSourceFile* SgSourceFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1112 
1113 // Methods for computing the total size of the memory pool. It actually returns the
1114 // size of the whole blocks allocated, no matter they contain valid pointers or not
1115 unsigned long SgSourceFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1116 void SgSourceFile_clearMemoryPool ( );
1117 void SgSourceFile_extendMemoryPoolForFileIO ( );
1118 unsigned long SgSourceFile_initializeStorageClassArray( SgSourceFileStorageClass *storageArray );
1119 void SgSourceFile_resetValidFreepointers( );
1120 unsigned long SgSourceFile_getNumberOfLastValidPointer();
1121 
1122 
1123 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1124 
1125 #include <semaphore.h>
1126 // DQ (9/21/2005): Static variables supporting memory pools
1133 extern int SgBinaryComposite_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1134 
1139 extern SgBinaryComposite* SgBinaryComposite_Current_Link; // = NULL;
1140 
1141 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1142 // This is was one of the things on the todo list (above).
1143 
1148 extern std::vector < unsigned char* > SgBinaryComposite_Memory_Block_List;
1149 /* */
1150 
1151 // DQ (4/6/2006): Newer code from Jochen
1152 // Methods to find the pointer to a global and local index
1153 SgBinaryComposite* SgBinaryComposite_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1154 SgBinaryComposite* SgBinaryComposite_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1155 
1156 // Methods for computing the total size of the memory pool. It actually returns the
1157 // size of the whole blocks allocated, no matter they contain valid pointers or not
1158 unsigned long SgBinaryComposite_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1159 void SgBinaryComposite_clearMemoryPool ( );
1160 void SgBinaryComposite_extendMemoryPoolForFileIO ( );
1161 unsigned long SgBinaryComposite_initializeStorageClassArray( SgBinaryCompositeStorageClass *storageArray );
1162 void SgBinaryComposite_resetValidFreepointers( );
1163 unsigned long SgBinaryComposite_getNumberOfLastValidPointer();
1164 
1165 
1166 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1167 
1168 #include <semaphore.h>
1169 // DQ (9/21/2005): Static variables supporting memory pools
1176 extern int SgUnknownFile_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1177 
1182 extern SgUnknownFile* SgUnknownFile_Current_Link; // = NULL;
1183 
1184 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1185 // This is was one of the things on the todo list (above).
1186 
1191 extern std::vector < unsigned char* > SgUnknownFile_Memory_Block_List;
1192 /* */
1193 
1194 // DQ (4/6/2006): Newer code from Jochen
1195 // Methods to find the pointer to a global and local index
1196 SgUnknownFile* SgUnknownFile_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1197 SgUnknownFile* SgUnknownFile_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1198 
1199 // Methods for computing the total size of the memory pool. It actually returns the
1200 // size of the whole blocks allocated, no matter they contain valid pointers or not
1201 unsigned long SgUnknownFile_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1202 void SgUnknownFile_clearMemoryPool ( );
1203 void SgUnknownFile_extendMemoryPoolForFileIO ( );
1204 unsigned long SgUnknownFile_initializeStorageClassArray( SgUnknownFileStorageClass *storageArray );
1205 void SgUnknownFile_resetValidFreepointers( );
1206 unsigned long SgUnknownFile_getNumberOfLastValidPointer();
1207 
1208 
1209 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1210 
1211 #include <semaphore.h>
1212 // DQ (9/21/2005): Static variables supporting memory pools
1219 extern int SgProject_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1220 
1225 extern SgProject* SgProject_Current_Link; // = NULL;
1226 
1227 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1228 // This is was one of the things on the todo list (above).
1229 
1234 extern std::vector < unsigned char* > SgProject_Memory_Block_List;
1235 /* */
1236 
1237 // DQ (4/6/2006): Newer code from Jochen
1238 // Methods to find the pointer to a global and local index
1239 SgProject* SgProject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1240 SgProject* SgProject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1241 
1242 // Methods for computing the total size of the memory pool. It actually returns the
1243 // size of the whole blocks allocated, no matter they contain valid pointers or not
1244 unsigned long SgProject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1245 void SgProject_clearMemoryPool ( );
1246 void SgProject_extendMemoryPoolForFileIO ( );
1247 unsigned long SgProject_initializeStorageClassArray( SgProjectStorageClass *storageArray );
1248 void SgProject_resetValidFreepointers( );
1249 unsigned long SgProject_getNumberOfLastValidPointer();
1250 
1251 
1252 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1253 
1254 #include <semaphore.h>
1255 // DQ (9/21/2005): Static variables supporting memory pools
1262 extern int SgOptions_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1263 
1268 extern SgOptions* SgOptions_Current_Link; // = NULL;
1269 
1270 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1271 // This is was one of the things on the todo list (above).
1272 
1277 extern std::vector < unsigned char* > SgOptions_Memory_Block_List;
1278 /* */
1279 
1280 // DQ (4/6/2006): Newer code from Jochen
1281 // Methods to find the pointer to a global and local index
1282 SgOptions* SgOptions_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1283 SgOptions* SgOptions_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1284 
1285 // Methods for computing the total size of the memory pool. It actually returns the
1286 // size of the whole blocks allocated, no matter they contain valid pointers or not
1287 unsigned long SgOptions_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1288 void SgOptions_clearMemoryPool ( );
1289 void SgOptions_extendMemoryPoolForFileIO ( );
1290 unsigned long SgOptions_initializeStorageClassArray( SgOptionsStorageClass *storageArray );
1291 void SgOptions_resetValidFreepointers( );
1292 unsigned long SgOptions_getNumberOfLastValidPointer();
1293 
1294 
1295 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1296 
1297 #include <semaphore.h>
1298 // DQ (9/21/2005): Static variables supporting memory pools
1305 extern int SgUnparse_Info_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1306 
1311 extern SgUnparse_Info* SgUnparse_Info_Current_Link; // = NULL;
1312 
1313 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1314 // This is was one of the things on the todo list (above).
1315 
1320 extern std::vector < unsigned char* > SgUnparse_Info_Memory_Block_List;
1321 /* */
1322 
1323 // DQ (4/6/2006): Newer code from Jochen
1324 // Methods to find the pointer to a global and local index
1325 SgUnparse_Info* SgUnparse_Info_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1326 SgUnparse_Info* SgUnparse_Info_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1327 
1328 // Methods for computing the total size of the memory pool. It actually returns the
1329 // size of the whole blocks allocated, no matter they contain valid pointers or not
1330 unsigned long SgUnparse_Info_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1331 void SgUnparse_Info_clearMemoryPool ( );
1332 void SgUnparse_Info_extendMemoryPoolForFileIO ( );
1333 unsigned long SgUnparse_Info_initializeStorageClassArray( SgUnparse_InfoStorageClass *storageArray );
1334 void SgUnparse_Info_resetValidFreepointers( );
1335 unsigned long SgUnparse_Info_getNumberOfLastValidPointer();
1336 
1337 
1338 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1339 
1340 #include <semaphore.h>
1341 // DQ (9/21/2005): Static variables supporting memory pools
1348 extern int SgBaseClass_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1349 
1354 extern SgBaseClass* SgBaseClass_Current_Link; // = NULL;
1355 
1356 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1357 // This is was one of the things on the todo list (above).
1358 
1363 extern std::vector < unsigned char* > SgBaseClass_Memory_Block_List;
1364 /* */
1365 
1366 // DQ (4/6/2006): Newer code from Jochen
1367 // Methods to find the pointer to a global and local index
1368 SgBaseClass* SgBaseClass_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1369 SgBaseClass* SgBaseClass_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1370 
1371 // Methods for computing the total size of the memory pool. It actually returns the
1372 // size of the whole blocks allocated, no matter they contain valid pointers or not
1373 unsigned long SgBaseClass_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1374 void SgBaseClass_clearMemoryPool ( );
1375 void SgBaseClass_extendMemoryPoolForFileIO ( );
1376 unsigned long SgBaseClass_initializeStorageClassArray( SgBaseClassStorageClass *storageArray );
1377 void SgBaseClass_resetValidFreepointers( );
1378 unsigned long SgBaseClass_getNumberOfLastValidPointer();
1379 
1380 
1381 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1382 
1383 #include <semaphore.h>
1384 // DQ (9/21/2005): Static variables supporting memory pools
1391 extern int SgExpBaseClass_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1392 
1397 extern SgExpBaseClass* SgExpBaseClass_Current_Link; // = NULL;
1398 
1399 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1400 // This is was one of the things on the todo list (above).
1401 
1406 extern std::vector < unsigned char* > SgExpBaseClass_Memory_Block_List;
1407 /* */
1408 
1409 // DQ (4/6/2006): Newer code from Jochen
1410 // Methods to find the pointer to a global and local index
1411 SgExpBaseClass* SgExpBaseClass_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1412 SgExpBaseClass* SgExpBaseClass_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1413 
1414 // Methods for computing the total size of the memory pool. It actually returns the
1415 // size of the whole blocks allocated, no matter they contain valid pointers or not
1416 unsigned long SgExpBaseClass_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1417 void SgExpBaseClass_clearMemoryPool ( );
1418 void SgExpBaseClass_extendMemoryPoolForFileIO ( );
1419 unsigned long SgExpBaseClass_initializeStorageClassArray( SgExpBaseClassStorageClass *storageArray );
1420 void SgExpBaseClass_resetValidFreepointers( );
1421 unsigned long SgExpBaseClass_getNumberOfLastValidPointer();
1422 
1423 
1424 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1425 
1426 #include <semaphore.h>
1427 // DQ (9/21/2005): Static variables supporting memory pools
1434 extern int SgTypedefSeq_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1435 
1440 extern SgTypedefSeq* SgTypedefSeq_Current_Link; // = NULL;
1441 
1442 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1443 // This is was one of the things on the todo list (above).
1444 
1449 extern std::vector < unsigned char* > SgTypedefSeq_Memory_Block_List;
1450 /* */
1451 
1452 // DQ (4/6/2006): Newer code from Jochen
1453 // Methods to find the pointer to a global and local index
1454 SgTypedefSeq* SgTypedefSeq_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1455 SgTypedefSeq* SgTypedefSeq_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1456 
1457 // Methods for computing the total size of the memory pool. It actually returns the
1458 // size of the whole blocks allocated, no matter they contain valid pointers or not
1459 unsigned long SgTypedefSeq_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1460 void SgTypedefSeq_clearMemoryPool ( );
1461 void SgTypedefSeq_extendMemoryPoolForFileIO ( );
1462 unsigned long SgTypedefSeq_initializeStorageClassArray( SgTypedefSeqStorageClass *storageArray );
1463 void SgTypedefSeq_resetValidFreepointers( );
1464 unsigned long SgTypedefSeq_getNumberOfLastValidPointer();
1465 
1466 
1467 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1468 
1469 #include <semaphore.h>
1470 // DQ (9/21/2005): Static variables supporting memory pools
1477 extern int SgTemplateParameter_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1478 
1483 extern SgTemplateParameter* SgTemplateParameter_Current_Link; // = NULL;
1484 
1485 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1486 // This is was one of the things on the todo list (above).
1487 
1492 extern std::vector < unsigned char* > SgTemplateParameter_Memory_Block_List;
1493 /* */
1494 
1495 // DQ (4/6/2006): Newer code from Jochen
1496 // Methods to find the pointer to a global and local index
1497 SgTemplateParameter* SgTemplateParameter_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1498 SgTemplateParameter* SgTemplateParameter_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1499 
1500 // Methods for computing the total size of the memory pool. It actually returns the
1501 // size of the whole blocks allocated, no matter they contain valid pointers or not
1502 unsigned long SgTemplateParameter_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1503 void SgTemplateParameter_clearMemoryPool ( );
1504 void SgTemplateParameter_extendMemoryPoolForFileIO ( );
1505 unsigned long SgTemplateParameter_initializeStorageClassArray( SgTemplateParameterStorageClass *storageArray );
1506 void SgTemplateParameter_resetValidFreepointers( );
1507 unsigned long SgTemplateParameter_getNumberOfLastValidPointer();
1508 
1509 
1510 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1511 
1512 #include <semaphore.h>
1513 // DQ (9/21/2005): Static variables supporting memory pools
1520 extern int SgTemplateArgument_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1521 
1526 extern SgTemplateArgument* SgTemplateArgument_Current_Link; // = NULL;
1527 
1528 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1529 // This is was one of the things on the todo list (above).
1530 
1535 extern std::vector < unsigned char* > SgTemplateArgument_Memory_Block_List;
1536 /* */
1537 
1538 // DQ (4/6/2006): Newer code from Jochen
1539 // Methods to find the pointer to a global and local index
1540 SgTemplateArgument* SgTemplateArgument_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1541 SgTemplateArgument* SgTemplateArgument_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1542 
1543 // Methods for computing the total size of the memory pool. It actually returns the
1544 // size of the whole blocks allocated, no matter they contain valid pointers or not
1545 unsigned long SgTemplateArgument_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1546 void SgTemplateArgument_clearMemoryPool ( );
1547 void SgTemplateArgument_extendMemoryPoolForFileIO ( );
1548 unsigned long SgTemplateArgument_initializeStorageClassArray( SgTemplateArgumentStorageClass *storageArray );
1549 void SgTemplateArgument_resetValidFreepointers( );
1550 unsigned long SgTemplateArgument_getNumberOfLastValidPointer();
1551 
1552 
1553 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1554 
1555 #include <semaphore.h>
1556 // DQ (9/21/2005): Static variables supporting memory pools
1563 extern int SgDirectory_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1564 
1569 extern SgDirectory* SgDirectory_Current_Link; // = NULL;
1570 
1571 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1572 // This is was one of the things on the todo list (above).
1573 
1578 extern std::vector < unsigned char* > SgDirectory_Memory_Block_List;
1579 /* */
1580 
1581 // DQ (4/6/2006): Newer code from Jochen
1582 // Methods to find the pointer to a global and local index
1583 SgDirectory* SgDirectory_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1584 SgDirectory* SgDirectory_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1585 
1586 // Methods for computing the total size of the memory pool. It actually returns the
1587 // size of the whole blocks allocated, no matter they contain valid pointers or not
1588 unsigned long SgDirectory_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1589 void SgDirectory_clearMemoryPool ( );
1590 void SgDirectory_extendMemoryPoolForFileIO ( );
1591 unsigned long SgDirectory_initializeStorageClassArray( SgDirectoryStorageClass *storageArray );
1592 void SgDirectory_resetValidFreepointers( );
1593 unsigned long SgDirectory_getNumberOfLastValidPointer();
1594 
1595 
1596 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1597 
1598 #include <semaphore.h>
1599 // DQ (9/21/2005): Static variables supporting memory pools
1606 extern int SgFileList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1607 
1612 extern SgFileList* SgFileList_Current_Link; // = NULL;
1613 
1614 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1615 // This is was one of the things on the todo list (above).
1616 
1621 extern std::vector < unsigned char* > SgFileList_Memory_Block_List;
1622 /* */
1623 
1624 // DQ (4/6/2006): Newer code from Jochen
1625 // Methods to find the pointer to a global and local index
1626 SgFileList* SgFileList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1627 SgFileList* SgFileList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1628 
1629 // Methods for computing the total size of the memory pool. It actually returns the
1630 // size of the whole blocks allocated, no matter they contain valid pointers or not
1631 unsigned long SgFileList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1632 void SgFileList_clearMemoryPool ( );
1633 void SgFileList_extendMemoryPoolForFileIO ( );
1634 unsigned long SgFileList_initializeStorageClassArray( SgFileListStorageClass *storageArray );
1635 void SgFileList_resetValidFreepointers( );
1636 unsigned long SgFileList_getNumberOfLastValidPointer();
1637 
1638 
1639 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1640 
1641 #include <semaphore.h>
1642 // DQ (9/21/2005): Static variables supporting memory pools
1649 extern int SgDirectoryList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1650 
1655 extern SgDirectoryList* SgDirectoryList_Current_Link; // = NULL;
1656 
1657 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1658 // This is was one of the things on the todo list (above).
1659 
1664 extern std::vector < unsigned char* > SgDirectoryList_Memory_Block_List;
1665 /* */
1666 
1667 // DQ (4/6/2006): Newer code from Jochen
1668 // Methods to find the pointer to a global and local index
1669 SgDirectoryList* SgDirectoryList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1670 SgDirectoryList* SgDirectoryList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1671 
1672 // Methods for computing the total size of the memory pool. It actually returns the
1673 // size of the whole blocks allocated, no matter they contain valid pointers or not
1674 unsigned long SgDirectoryList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1675 void SgDirectoryList_clearMemoryPool ( );
1676 void SgDirectoryList_extendMemoryPoolForFileIO ( );
1677 unsigned long SgDirectoryList_initializeStorageClassArray( SgDirectoryListStorageClass *storageArray );
1678 void SgDirectoryList_resetValidFreepointers( );
1679 unsigned long SgDirectoryList_getNumberOfLastValidPointer();
1680 
1681 
1682 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1683 
1684 #include <semaphore.h>
1685 // DQ (9/21/2005): Static variables supporting memory pools
1692 extern int SgFunctionParameterTypeList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1693 
1698 extern SgFunctionParameterTypeList* SgFunctionParameterTypeList_Current_Link; // = NULL;
1699 
1700 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1701 // This is was one of the things on the todo list (above).
1702 
1707 extern std::vector < unsigned char* > SgFunctionParameterTypeList_Memory_Block_List;
1708 /* */
1709 
1710 // DQ (4/6/2006): Newer code from Jochen
1711 // Methods to find the pointer to a global and local index
1712 SgFunctionParameterTypeList* SgFunctionParameterTypeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1713 SgFunctionParameterTypeList* SgFunctionParameterTypeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1714 
1715 // Methods for computing the total size of the memory pool. It actually returns the
1716 // size of the whole blocks allocated, no matter they contain valid pointers or not
1717 unsigned long SgFunctionParameterTypeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1718 void SgFunctionParameterTypeList_clearMemoryPool ( );
1719 void SgFunctionParameterTypeList_extendMemoryPoolForFileIO ( );
1720 unsigned long SgFunctionParameterTypeList_initializeStorageClassArray( SgFunctionParameterTypeListStorageClass *storageArray );
1721 void SgFunctionParameterTypeList_resetValidFreepointers( );
1722 unsigned long SgFunctionParameterTypeList_getNumberOfLastValidPointer();
1723 
1724 
1725 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1726 
1727 #include <semaphore.h>
1728 // DQ (9/21/2005): Static variables supporting memory pools
1735 extern int SgQualifiedName_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1736 
1741 extern SgQualifiedName* SgQualifiedName_Current_Link; // = NULL;
1742 
1743 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1744 // This is was one of the things on the todo list (above).
1745 
1750 extern std::vector < unsigned char* > SgQualifiedName_Memory_Block_List;
1751 /* */
1752 
1753 // DQ (4/6/2006): Newer code from Jochen
1754 // Methods to find the pointer to a global and local index
1755 SgQualifiedName* SgQualifiedName_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1756 SgQualifiedName* SgQualifiedName_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1757 
1758 // Methods for computing the total size of the memory pool. It actually returns the
1759 // size of the whole blocks allocated, no matter they contain valid pointers or not
1760 unsigned long SgQualifiedName_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1761 void SgQualifiedName_clearMemoryPool ( );
1762 void SgQualifiedName_extendMemoryPoolForFileIO ( );
1763 unsigned long SgQualifiedName_initializeStorageClassArray( SgQualifiedNameStorageClass *storageArray );
1764 void SgQualifiedName_resetValidFreepointers( );
1765 unsigned long SgQualifiedName_getNumberOfLastValidPointer();
1766 
1767 
1768 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1769 
1770 #include <semaphore.h>
1771 // DQ (9/21/2005): Static variables supporting memory pools
1778 extern int SgTemplateArgumentList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1779 
1784 extern SgTemplateArgumentList* SgTemplateArgumentList_Current_Link; // = NULL;
1785 
1786 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1787 // This is was one of the things on the todo list (above).
1788 
1793 extern std::vector < unsigned char* > SgTemplateArgumentList_Memory_Block_List;
1794 /* */
1795 
1796 // DQ (4/6/2006): Newer code from Jochen
1797 // Methods to find the pointer to a global and local index
1798 SgTemplateArgumentList* SgTemplateArgumentList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1799 SgTemplateArgumentList* SgTemplateArgumentList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1800 
1801 // Methods for computing the total size of the memory pool. It actually returns the
1802 // size of the whole blocks allocated, no matter they contain valid pointers or not
1803 unsigned long SgTemplateArgumentList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1804 void SgTemplateArgumentList_clearMemoryPool ( );
1805 void SgTemplateArgumentList_extendMemoryPoolForFileIO ( );
1806 unsigned long SgTemplateArgumentList_initializeStorageClassArray( SgTemplateArgumentListStorageClass *storageArray );
1807 void SgTemplateArgumentList_resetValidFreepointers( );
1808 unsigned long SgTemplateArgumentList_getNumberOfLastValidPointer();
1809 
1810 
1811 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1812 
1813 #include <semaphore.h>
1814 // DQ (9/21/2005): Static variables supporting memory pools
1821 extern int SgTemplateParameterList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1822 
1827 extern SgTemplateParameterList* SgTemplateParameterList_Current_Link; // = NULL;
1828 
1829 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1830 // This is was one of the things on the todo list (above).
1831 
1836 extern std::vector < unsigned char* > SgTemplateParameterList_Memory_Block_List;
1837 /* */
1838 
1839 // DQ (4/6/2006): Newer code from Jochen
1840 // Methods to find the pointer to a global and local index
1841 SgTemplateParameterList* SgTemplateParameterList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1842 SgTemplateParameterList* SgTemplateParameterList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1843 
1844 // Methods for computing the total size of the memory pool. It actually returns the
1845 // size of the whole blocks allocated, no matter they contain valid pointers or not
1846 unsigned long SgTemplateParameterList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1847 void SgTemplateParameterList_clearMemoryPool ( );
1848 void SgTemplateParameterList_extendMemoryPoolForFileIO ( );
1849 unsigned long SgTemplateParameterList_initializeStorageClassArray( SgTemplateParameterListStorageClass *storageArray );
1850 void SgTemplateParameterList_resetValidFreepointers( );
1851 unsigned long SgTemplateParameterList_getNumberOfLastValidPointer();
1852 
1853 
1854 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1855 
1856 #include <semaphore.h>
1857 // DQ (9/21/2005): Static variables supporting memory pools
1864 extern int SgGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1865 
1870 extern SgGraph* SgGraph_Current_Link; // = NULL;
1871 
1872 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1873 // This is was one of the things on the todo list (above).
1874 
1879 extern std::vector < unsigned char* > SgGraph_Memory_Block_List;
1880 /* */
1881 
1882 // DQ (4/6/2006): Newer code from Jochen
1883 // Methods to find the pointer to a global and local index
1884 SgGraph* SgGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1885 SgGraph* SgGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1886 
1887 // Methods for computing the total size of the memory pool. It actually returns the
1888 // size of the whole blocks allocated, no matter they contain valid pointers or not
1889 unsigned long SgGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1890 void SgGraph_clearMemoryPool ( );
1891 void SgGraph_extendMemoryPoolForFileIO ( );
1892 unsigned long SgGraph_initializeStorageClassArray( SgGraphStorageClass *storageArray );
1893 void SgGraph_resetValidFreepointers( );
1894 unsigned long SgGraph_getNumberOfLastValidPointer();
1895 
1896 
1897 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1898 
1899 #include <semaphore.h>
1900 // DQ (9/21/2005): Static variables supporting memory pools
1907 extern int SgIncidenceDirectedGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1908 
1913 extern SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_Current_Link; // = NULL;
1914 
1915 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1916 // This is was one of the things on the todo list (above).
1917 
1922 extern std::vector < unsigned char* > SgIncidenceDirectedGraph_Memory_Block_List;
1923 /* */
1924 
1925 // DQ (4/6/2006): Newer code from Jochen
1926 // Methods to find the pointer to a global and local index
1927 SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1928 SgIncidenceDirectedGraph* SgIncidenceDirectedGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1929 
1930 // Methods for computing the total size of the memory pool. It actually returns the
1931 // size of the whole blocks allocated, no matter they contain valid pointers or not
1932 unsigned long SgIncidenceDirectedGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1933 void SgIncidenceDirectedGraph_clearMemoryPool ( );
1934 void SgIncidenceDirectedGraph_extendMemoryPoolForFileIO ( );
1935 unsigned long SgIncidenceDirectedGraph_initializeStorageClassArray( SgIncidenceDirectedGraphStorageClass *storageArray );
1936 void SgIncidenceDirectedGraph_resetValidFreepointers( );
1937 unsigned long SgIncidenceDirectedGraph_getNumberOfLastValidPointer();
1938 
1939 
1940 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1941 
1942 #include <semaphore.h>
1943 // DQ (9/21/2005): Static variables supporting memory pools
1950 extern int SgBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1951 
1956 extern SgBidirectionalGraph* SgBidirectionalGraph_Current_Link; // = NULL;
1957 
1958 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
1959 // This is was one of the things on the todo list (above).
1960 
1965 extern std::vector < unsigned char* > SgBidirectionalGraph_Memory_Block_List;
1966 /* */
1967 
1968 // DQ (4/6/2006): Newer code from Jochen
1969 // Methods to find the pointer to a global and local index
1970 SgBidirectionalGraph* SgBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
1971 SgBidirectionalGraph* SgBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
1972 
1973 // Methods for computing the total size of the memory pool. It actually returns the
1974 // size of the whole blocks allocated, no matter they contain valid pointers or not
1975 unsigned long SgBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
1976 void SgBidirectionalGraph_clearMemoryPool ( );
1977 void SgBidirectionalGraph_extendMemoryPoolForFileIO ( );
1978 unsigned long SgBidirectionalGraph_initializeStorageClassArray( SgBidirectionalGraphStorageClass *storageArray );
1979 void SgBidirectionalGraph_resetValidFreepointers( );
1980 unsigned long SgBidirectionalGraph_getNumberOfLastValidPointer();
1981 
1982 
1983 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
1984 
1985 #include <semaphore.h>
1986 // DQ (9/21/2005): Static variables supporting memory pools
1993 extern int SgStringKeyedBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
1994 
1999 extern SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_Current_Link; // = NULL;
2000 
2001 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2002 // This is was one of the things on the todo list (above).
2003 
2008 extern std::vector < unsigned char* > SgStringKeyedBidirectionalGraph_Memory_Block_List;
2009 /* */
2010 
2011 // DQ (4/6/2006): Newer code from Jochen
2012 // Methods to find the pointer to a global and local index
2013 SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2014 SgStringKeyedBidirectionalGraph* SgStringKeyedBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2015 
2016 // Methods for computing the total size of the memory pool. It actually returns the
2017 // size of the whole blocks allocated, no matter they contain valid pointers or not
2018 unsigned long SgStringKeyedBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2019 void SgStringKeyedBidirectionalGraph_clearMemoryPool ( );
2020 void SgStringKeyedBidirectionalGraph_extendMemoryPoolForFileIO ( );
2021 unsigned long SgStringKeyedBidirectionalGraph_initializeStorageClassArray( SgStringKeyedBidirectionalGraphStorageClass *storageArray );
2022 void SgStringKeyedBidirectionalGraph_resetValidFreepointers( );
2023 unsigned long SgStringKeyedBidirectionalGraph_getNumberOfLastValidPointer();
2024 
2025 
2026 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2027 
2028 #include <semaphore.h>
2029 // DQ (9/21/2005): Static variables supporting memory pools
2036 extern int SgIntKeyedBidirectionalGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2037 
2042 extern SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_Current_Link; // = NULL;
2043 
2044 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2045 // This is was one of the things on the todo list (above).
2046 
2051 extern std::vector < unsigned char* > SgIntKeyedBidirectionalGraph_Memory_Block_List;
2052 /* */
2053 
2054 // DQ (4/6/2006): Newer code from Jochen
2055 // Methods to find the pointer to a global and local index
2056 SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2057 SgIntKeyedBidirectionalGraph* SgIntKeyedBidirectionalGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2058 
2059 // Methods for computing the total size of the memory pool. It actually returns the
2060 // size of the whole blocks allocated, no matter they contain valid pointers or not
2061 unsigned long SgIntKeyedBidirectionalGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2062 void SgIntKeyedBidirectionalGraph_clearMemoryPool ( );
2063 void SgIntKeyedBidirectionalGraph_extendMemoryPoolForFileIO ( );
2064 unsigned long SgIntKeyedBidirectionalGraph_initializeStorageClassArray( SgIntKeyedBidirectionalGraphStorageClass *storageArray );
2065 void SgIntKeyedBidirectionalGraph_resetValidFreepointers( );
2066 unsigned long SgIntKeyedBidirectionalGraph_getNumberOfLastValidPointer();
2067 
2068 
2069 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2070 
2071 #include <semaphore.h>
2072 // DQ (9/21/2005): Static variables supporting memory pools
2079 extern int SgIncidenceUndirectedGraph_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2080 
2085 extern SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_Current_Link; // = NULL;
2086 
2087 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2088 // This is was one of the things on the todo list (above).
2089 
2094 extern std::vector < unsigned char* > SgIncidenceUndirectedGraph_Memory_Block_List;
2095 /* */
2096 
2097 // DQ (4/6/2006): Newer code from Jochen
2098 // Methods to find the pointer to a global and local index
2099 SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2100 SgIncidenceUndirectedGraph* SgIncidenceUndirectedGraph_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2101 
2102 // Methods for computing the total size of the memory pool. It actually returns the
2103 // size of the whole blocks allocated, no matter they contain valid pointers or not
2104 unsigned long SgIncidenceUndirectedGraph_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2105 void SgIncidenceUndirectedGraph_clearMemoryPool ( );
2106 void SgIncidenceUndirectedGraph_extendMemoryPoolForFileIO ( );
2107 unsigned long SgIncidenceUndirectedGraph_initializeStorageClassArray( SgIncidenceUndirectedGraphStorageClass *storageArray );
2108 void SgIncidenceUndirectedGraph_resetValidFreepointers( );
2109 unsigned long SgIncidenceUndirectedGraph_getNumberOfLastValidPointer();
2110 
2111 
2112 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2113 
2114 #include <semaphore.h>
2115 // DQ (9/21/2005): Static variables supporting memory pools
2122 extern int SgGraphNode_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2123 
2128 extern SgGraphNode* SgGraphNode_Current_Link; // = NULL;
2129 
2130 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2131 // This is was one of the things on the todo list (above).
2132 
2137 extern std::vector < unsigned char* > SgGraphNode_Memory_Block_List;
2138 /* */
2139 
2140 // DQ (4/6/2006): Newer code from Jochen
2141 // Methods to find the pointer to a global and local index
2142 SgGraphNode* SgGraphNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2143 SgGraphNode* SgGraphNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2144 
2145 // Methods for computing the total size of the memory pool. It actually returns the
2146 // size of the whole blocks allocated, no matter they contain valid pointers or not
2147 unsigned long SgGraphNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2148 void SgGraphNode_clearMemoryPool ( );
2149 void SgGraphNode_extendMemoryPoolForFileIO ( );
2150 unsigned long SgGraphNode_initializeStorageClassArray( SgGraphNodeStorageClass *storageArray );
2151 void SgGraphNode_resetValidFreepointers( );
2152 unsigned long SgGraphNode_getNumberOfLastValidPointer();
2153 
2154 
2155 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2156 
2157 #include <semaphore.h>
2158 // DQ (9/21/2005): Static variables supporting memory pools
2165 extern int SgGraphEdge_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2166 
2171 extern SgGraphEdge* SgGraphEdge_Current_Link; // = NULL;
2172 
2173 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2174 // This is was one of the things on the todo list (above).
2175 
2180 extern std::vector < unsigned char* > SgGraphEdge_Memory_Block_List;
2181 /* */
2182 
2183 // DQ (4/6/2006): Newer code from Jochen
2184 // Methods to find the pointer to a global and local index
2185 SgGraphEdge* SgGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2186 SgGraphEdge* SgGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2187 
2188 // Methods for computing the total size of the memory pool. It actually returns the
2189 // size of the whole blocks allocated, no matter they contain valid pointers or not
2190 unsigned long SgGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2191 void SgGraphEdge_clearMemoryPool ( );
2192 void SgGraphEdge_extendMemoryPoolForFileIO ( );
2193 unsigned long SgGraphEdge_initializeStorageClassArray( SgGraphEdgeStorageClass *storageArray );
2194 void SgGraphEdge_resetValidFreepointers( );
2195 unsigned long SgGraphEdge_getNumberOfLastValidPointer();
2196 
2197 
2198 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2199 
2200 #include <semaphore.h>
2201 // DQ (9/21/2005): Static variables supporting memory pools
2208 extern int SgDirectedGraphEdge_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2209 
2214 extern SgDirectedGraphEdge* SgDirectedGraphEdge_Current_Link; // = NULL;
2215 
2216 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2217 // This is was one of the things on the todo list (above).
2218 
2223 extern std::vector < unsigned char* > SgDirectedGraphEdge_Memory_Block_List;
2224 /* */
2225 
2226 // DQ (4/6/2006): Newer code from Jochen
2227 // Methods to find the pointer to a global and local index
2228 SgDirectedGraphEdge* SgDirectedGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2229 SgDirectedGraphEdge* SgDirectedGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2230 
2231 // Methods for computing the total size of the memory pool. It actually returns the
2232 // size of the whole blocks allocated, no matter they contain valid pointers or not
2233 unsigned long SgDirectedGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2234 void SgDirectedGraphEdge_clearMemoryPool ( );
2235 void SgDirectedGraphEdge_extendMemoryPoolForFileIO ( );
2236 unsigned long SgDirectedGraphEdge_initializeStorageClassArray( SgDirectedGraphEdgeStorageClass *storageArray );
2237 void SgDirectedGraphEdge_resetValidFreepointers( );
2238 unsigned long SgDirectedGraphEdge_getNumberOfLastValidPointer();
2239 
2240 
2241 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2242 
2243 #include <semaphore.h>
2244 // DQ (9/21/2005): Static variables supporting memory pools
2251 extern int SgUndirectedGraphEdge_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2252 
2257 extern SgUndirectedGraphEdge* SgUndirectedGraphEdge_Current_Link; // = NULL;
2258 
2259 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2260 // This is was one of the things on the todo list (above).
2261 
2266 extern std::vector < unsigned char* > SgUndirectedGraphEdge_Memory_Block_List;
2267 /* */
2268 
2269 // DQ (4/6/2006): Newer code from Jochen
2270 // Methods to find the pointer to a global and local index
2271 SgUndirectedGraphEdge* SgUndirectedGraphEdge_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2272 SgUndirectedGraphEdge* SgUndirectedGraphEdge_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2273 
2274 // Methods for computing the total size of the memory pool. It actually returns the
2275 // size of the whole blocks allocated, no matter they contain valid pointers or not
2276 unsigned long SgUndirectedGraphEdge_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2277 void SgUndirectedGraphEdge_clearMemoryPool ( );
2278 void SgUndirectedGraphEdge_extendMemoryPoolForFileIO ( );
2279 unsigned long SgUndirectedGraphEdge_initializeStorageClassArray( SgUndirectedGraphEdgeStorageClass *storageArray );
2280 void SgUndirectedGraphEdge_resetValidFreepointers( );
2281 unsigned long SgUndirectedGraphEdge_getNumberOfLastValidPointer();
2282 
2283 
2284 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2285 
2286 #include <semaphore.h>
2287 // DQ (9/21/2005): Static variables supporting memory pools
2294 extern int SgGraphNodeList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2295 
2300 extern SgGraphNodeList* SgGraphNodeList_Current_Link; // = NULL;
2301 
2302 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2303 // This is was one of the things on the todo list (above).
2304 
2309 extern std::vector < unsigned char* > SgGraphNodeList_Memory_Block_List;
2310 /* */
2311 
2312 // DQ (4/6/2006): Newer code from Jochen
2313 // Methods to find the pointer to a global and local index
2314 SgGraphNodeList* SgGraphNodeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2315 SgGraphNodeList* SgGraphNodeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2316 
2317 // Methods for computing the total size of the memory pool. It actually returns the
2318 // size of the whole blocks allocated, no matter they contain valid pointers or not
2319 unsigned long SgGraphNodeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2320 void SgGraphNodeList_clearMemoryPool ( );
2321 void SgGraphNodeList_extendMemoryPoolForFileIO ( );
2322 unsigned long SgGraphNodeList_initializeStorageClassArray( SgGraphNodeListStorageClass *storageArray );
2323 void SgGraphNodeList_resetValidFreepointers( );
2324 unsigned long SgGraphNodeList_getNumberOfLastValidPointer();
2325 
2326 
2327 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2328 
2329 #include <semaphore.h>
2330 // DQ (9/21/2005): Static variables supporting memory pools
2337 extern int SgGraphEdgeList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2338 
2343 extern SgGraphEdgeList* SgGraphEdgeList_Current_Link; // = NULL;
2344 
2345 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2346 // This is was one of the things on the todo list (above).
2347 
2352 extern std::vector < unsigned char* > SgGraphEdgeList_Memory_Block_List;
2353 /* */
2354 
2355 // DQ (4/6/2006): Newer code from Jochen
2356 // Methods to find the pointer to a global and local index
2357 SgGraphEdgeList* SgGraphEdgeList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2358 SgGraphEdgeList* SgGraphEdgeList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2359 
2360 // Methods for computing the total size of the memory pool. It actually returns the
2361 // size of the whole blocks allocated, no matter they contain valid pointers or not
2362 unsigned long SgGraphEdgeList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2363 void SgGraphEdgeList_clearMemoryPool ( );
2364 void SgGraphEdgeList_extendMemoryPoolForFileIO ( );
2365 unsigned long SgGraphEdgeList_initializeStorageClassArray( SgGraphEdgeListStorageClass *storageArray );
2366 void SgGraphEdgeList_resetValidFreepointers( );
2367 unsigned long SgGraphEdgeList_getNumberOfLastValidPointer();
2368 
2369 
2370 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2371 
2372 #include <semaphore.h>
2373 // DQ (9/21/2005): Static variables supporting memory pools
2380 extern int SgTypeTable_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2381 
2386 extern SgTypeTable* SgTypeTable_Current_Link; // = NULL;
2387 
2388 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2389 // This is was one of the things on the todo list (above).
2390 
2395 extern std::vector < unsigned char* > SgTypeTable_Memory_Block_List;
2396 /* */
2397 
2398 // DQ (4/6/2006): Newer code from Jochen
2399 // Methods to find the pointer to a global and local index
2400 SgTypeTable* SgTypeTable_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2401 SgTypeTable* SgTypeTable_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2402 
2403 // Methods for computing the total size of the memory pool. It actually returns the
2404 // size of the whole blocks allocated, no matter they contain valid pointers or not
2405 unsigned long SgTypeTable_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2406 void SgTypeTable_clearMemoryPool ( );
2407 void SgTypeTable_extendMemoryPoolForFileIO ( );
2408 unsigned long SgTypeTable_initializeStorageClassArray( SgTypeTableStorageClass *storageArray );
2409 void SgTypeTable_resetValidFreepointers( );
2410 unsigned long SgTypeTable_getNumberOfLastValidPointer();
2411 
2412 
2413 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2414 
2415 #include <semaphore.h>
2416 // DQ (9/21/2005): Static variables supporting memory pools
2423 extern int SgNameGroup_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2424 
2429 extern SgNameGroup* SgNameGroup_Current_Link; // = NULL;
2430 
2431 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2432 // This is was one of the things on the todo list (above).
2433 
2438 extern std::vector < unsigned char* > SgNameGroup_Memory_Block_List;
2439 /* */
2440 
2441 // DQ (4/6/2006): Newer code from Jochen
2442 // Methods to find the pointer to a global and local index
2443 SgNameGroup* SgNameGroup_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2444 SgNameGroup* SgNameGroup_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2445 
2446 // Methods for computing the total size of the memory pool. It actually returns the
2447 // size of the whole blocks allocated, no matter they contain valid pointers or not
2448 unsigned long SgNameGroup_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2449 void SgNameGroup_clearMemoryPool ( );
2450 void SgNameGroup_extendMemoryPoolForFileIO ( );
2451 unsigned long SgNameGroup_initializeStorageClassArray( SgNameGroupStorageClass *storageArray );
2452 void SgNameGroup_resetValidFreepointers( );
2453 unsigned long SgNameGroup_getNumberOfLastValidPointer();
2454 
2455 
2456 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2457 
2458 #include <semaphore.h>
2459 // DQ (9/21/2005): Static variables supporting memory pools
2466 extern int SgDimensionObject_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2467 
2472 extern SgDimensionObject* SgDimensionObject_Current_Link; // = NULL;
2473 
2474 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2475 // This is was one of the things on the todo list (above).
2476 
2481 extern std::vector < unsigned char* > SgDimensionObject_Memory_Block_List;
2482 /* */
2483 
2484 // DQ (4/6/2006): Newer code from Jochen
2485 // Methods to find the pointer to a global and local index
2486 SgDimensionObject* SgDimensionObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2487 SgDimensionObject* SgDimensionObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2488 
2489 // Methods for computing the total size of the memory pool. It actually returns the
2490 // size of the whole blocks allocated, no matter they contain valid pointers or not
2491 unsigned long SgDimensionObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2492 void SgDimensionObject_clearMemoryPool ( );
2493 void SgDimensionObject_extendMemoryPoolForFileIO ( );
2494 unsigned long SgDimensionObject_initializeStorageClassArray( SgDimensionObjectStorageClass *storageArray );
2495 void SgDimensionObject_resetValidFreepointers( );
2496 unsigned long SgDimensionObject_getNumberOfLastValidPointer();
2497 
2498 
2499 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2500 
2501 #include <semaphore.h>
2502 // DQ (9/21/2005): Static variables supporting memory pools
2509 extern int SgFormatItem_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2510 
2515 extern SgFormatItem* SgFormatItem_Current_Link; // = NULL;
2516 
2517 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2518 // This is was one of the things on the todo list (above).
2519 
2524 extern std::vector < unsigned char* > SgFormatItem_Memory_Block_List;
2525 /* */
2526 
2527 // DQ (4/6/2006): Newer code from Jochen
2528 // Methods to find the pointer to a global and local index
2529 SgFormatItem* SgFormatItem_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2530 SgFormatItem* SgFormatItem_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2531 
2532 // Methods for computing the total size of the memory pool. It actually returns the
2533 // size of the whole blocks allocated, no matter they contain valid pointers or not
2534 unsigned long SgFormatItem_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2535 void SgFormatItem_clearMemoryPool ( );
2536 void SgFormatItem_extendMemoryPoolForFileIO ( );
2537 unsigned long SgFormatItem_initializeStorageClassArray( SgFormatItemStorageClass *storageArray );
2538 void SgFormatItem_resetValidFreepointers( );
2539 unsigned long SgFormatItem_getNumberOfLastValidPointer();
2540 
2541 
2542 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2543 
2544 #include <semaphore.h>
2545 // DQ (9/21/2005): Static variables supporting memory pools
2552 extern int SgFormatItemList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2553 
2558 extern SgFormatItemList* SgFormatItemList_Current_Link; // = NULL;
2559 
2560 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2561 // This is was one of the things on the todo list (above).
2562 
2567 extern std::vector < unsigned char* > SgFormatItemList_Memory_Block_List;
2568 /* */
2569 
2570 // DQ (4/6/2006): Newer code from Jochen
2571 // Methods to find the pointer to a global and local index
2572 SgFormatItemList* SgFormatItemList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2573 SgFormatItemList* SgFormatItemList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2574 
2575 // Methods for computing the total size of the memory pool. It actually returns the
2576 // size of the whole blocks allocated, no matter they contain valid pointers or not
2577 unsigned long SgFormatItemList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2578 void SgFormatItemList_clearMemoryPool ( );
2579 void SgFormatItemList_extendMemoryPoolForFileIO ( );
2580 unsigned long SgFormatItemList_initializeStorageClassArray( SgFormatItemListStorageClass *storageArray );
2581 void SgFormatItemList_resetValidFreepointers( );
2582 unsigned long SgFormatItemList_getNumberOfLastValidPointer();
2583 
2584 
2585 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2586 
2587 #include <semaphore.h>
2588 // DQ (9/21/2005): Static variables supporting memory pools
2595 extern int SgDataStatementGroup_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2596 
2601 extern SgDataStatementGroup* SgDataStatementGroup_Current_Link; // = NULL;
2602 
2603 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2604 // This is was one of the things on the todo list (above).
2605 
2610 extern std::vector < unsigned char* > SgDataStatementGroup_Memory_Block_List;
2611 /* */
2612 
2613 // DQ (4/6/2006): Newer code from Jochen
2614 // Methods to find the pointer to a global and local index
2615 SgDataStatementGroup* SgDataStatementGroup_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2616 SgDataStatementGroup* SgDataStatementGroup_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2617 
2618 // Methods for computing the total size of the memory pool. It actually returns the
2619 // size of the whole blocks allocated, no matter they contain valid pointers or not
2620 unsigned long SgDataStatementGroup_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2621 void SgDataStatementGroup_clearMemoryPool ( );
2622 void SgDataStatementGroup_extendMemoryPoolForFileIO ( );
2623 unsigned long SgDataStatementGroup_initializeStorageClassArray( SgDataStatementGroupStorageClass *storageArray );
2624 void SgDataStatementGroup_resetValidFreepointers( );
2625 unsigned long SgDataStatementGroup_getNumberOfLastValidPointer();
2626 
2627 
2628 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2629 
2630 #include <semaphore.h>
2631 // DQ (9/21/2005): Static variables supporting memory pools
2638 extern int SgDataStatementObject_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2639 
2644 extern SgDataStatementObject* SgDataStatementObject_Current_Link; // = NULL;
2645 
2646 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2647 // This is was one of the things on the todo list (above).
2648 
2653 extern std::vector < unsigned char* > SgDataStatementObject_Memory_Block_List;
2654 /* */
2655 
2656 // DQ (4/6/2006): Newer code from Jochen
2657 // Methods to find the pointer to a global and local index
2658 SgDataStatementObject* SgDataStatementObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2659 SgDataStatementObject* SgDataStatementObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2660 
2661 // Methods for computing the total size of the memory pool. It actually returns the
2662 // size of the whole blocks allocated, no matter they contain valid pointers or not
2663 unsigned long SgDataStatementObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2664 void SgDataStatementObject_clearMemoryPool ( );
2665 void SgDataStatementObject_extendMemoryPoolForFileIO ( );
2666 unsigned long SgDataStatementObject_initializeStorageClassArray( SgDataStatementObjectStorageClass *storageArray );
2667 void SgDataStatementObject_resetValidFreepointers( );
2668 unsigned long SgDataStatementObject_getNumberOfLastValidPointer();
2669 
2670 
2671 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2672 
2673 #include <semaphore.h>
2674 // DQ (9/21/2005): Static variables supporting memory pools
2681 extern int SgDataStatementValue_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2682 
2687 extern SgDataStatementValue* SgDataStatementValue_Current_Link; // = NULL;
2688 
2689 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2690 // This is was one of the things on the todo list (above).
2691 
2696 extern std::vector < unsigned char* > SgDataStatementValue_Memory_Block_List;
2697 /* */
2698 
2699 // DQ (4/6/2006): Newer code from Jochen
2700 // Methods to find the pointer to a global and local index
2701 SgDataStatementValue* SgDataStatementValue_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2702 SgDataStatementValue* SgDataStatementValue_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2703 
2704 // Methods for computing the total size of the memory pool. It actually returns the
2705 // size of the whole blocks allocated, no matter they contain valid pointers or not
2706 unsigned long SgDataStatementValue_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2707 void SgDataStatementValue_clearMemoryPool ( );
2708 void SgDataStatementValue_extendMemoryPoolForFileIO ( );
2709 unsigned long SgDataStatementValue_initializeStorageClassArray( SgDataStatementValueStorageClass *storageArray );
2710 void SgDataStatementValue_resetValidFreepointers( );
2711 unsigned long SgDataStatementValue_getNumberOfLastValidPointer();
2712 
2713 
2714 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2715 
2716 #include <semaphore.h>
2717 // DQ (9/21/2005): Static variables supporting memory pools
2724 extern int SgJavaImportStatementList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2725 
2730 extern SgJavaImportStatementList* SgJavaImportStatementList_Current_Link; // = NULL;
2731 
2732 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2733 // This is was one of the things on the todo list (above).
2734 
2739 extern std::vector < unsigned char* > SgJavaImportStatementList_Memory_Block_List;
2740 /* */
2741 
2742 // DQ (4/6/2006): Newer code from Jochen
2743 // Methods to find the pointer to a global and local index
2744 SgJavaImportStatementList* SgJavaImportStatementList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2745 SgJavaImportStatementList* SgJavaImportStatementList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2746 
2747 // Methods for computing the total size of the memory pool. It actually returns the
2748 // size of the whole blocks allocated, no matter they contain valid pointers or not
2749 unsigned long SgJavaImportStatementList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2750 void SgJavaImportStatementList_clearMemoryPool ( );
2751 void SgJavaImportStatementList_extendMemoryPoolForFileIO ( );
2752 unsigned long SgJavaImportStatementList_initializeStorageClassArray( SgJavaImportStatementListStorageClass *storageArray );
2753 void SgJavaImportStatementList_resetValidFreepointers( );
2754 unsigned long SgJavaImportStatementList_getNumberOfLastValidPointer();
2755 
2756 
2757 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2758 
2759 #include <semaphore.h>
2760 // DQ (9/21/2005): Static variables supporting memory pools
2767 extern int SgJavaClassDeclarationList_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2768 
2773 extern SgJavaClassDeclarationList* SgJavaClassDeclarationList_Current_Link; // = NULL;
2774 
2775 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2776 // This is was one of the things on the todo list (above).
2777 
2782 extern std::vector < unsigned char* > SgJavaClassDeclarationList_Memory_Block_List;
2783 /* */
2784 
2785 // DQ (4/6/2006): Newer code from Jochen
2786 // Methods to find the pointer to a global and local index
2787 SgJavaClassDeclarationList* SgJavaClassDeclarationList_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2788 SgJavaClassDeclarationList* SgJavaClassDeclarationList_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2789 
2790 // Methods for computing the total size of the memory pool. It actually returns the
2791 // size of the whole blocks allocated, no matter they contain valid pointers or not
2792 unsigned long SgJavaClassDeclarationList_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2793 void SgJavaClassDeclarationList_clearMemoryPool ( );
2794 void SgJavaClassDeclarationList_extendMemoryPoolForFileIO ( );
2795 unsigned long SgJavaClassDeclarationList_initializeStorageClassArray( SgJavaClassDeclarationListStorageClass *storageArray );
2796 void SgJavaClassDeclarationList_resetValidFreepointers( );
2797 unsigned long SgJavaClassDeclarationList_getNumberOfLastValidPointer();
2798 
2799 
2800 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2801 
2802 #include <semaphore.h>
2803 // DQ (9/21/2005): Static variables supporting memory pools
2810 extern int SgType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2811 
2816 extern SgType* SgType_Current_Link; // = NULL;
2817 
2818 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2819 // This is was one of the things on the todo list (above).
2820 
2825 extern std::vector < unsigned char* > SgType_Memory_Block_List;
2826 /* */
2827 
2828 // DQ (4/6/2006): Newer code from Jochen
2829 // Methods to find the pointer to a global and local index
2830 SgType* SgType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2831 SgType* SgType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2832 
2833 // Methods for computing the total size of the memory pool. It actually returns the
2834 // size of the whole blocks allocated, no matter they contain valid pointers or not
2835 unsigned long SgType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2836 void SgType_clearMemoryPool ( );
2837 void SgType_extendMemoryPoolForFileIO ( );
2838 unsigned long SgType_initializeStorageClassArray( SgTypeStorageClass *storageArray );
2839 void SgType_resetValidFreepointers( );
2840 unsigned long SgType_getNumberOfLastValidPointer();
2841 
2842 
2843 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2844 
2845 #include <semaphore.h>
2846 // DQ (9/21/2005): Static variables supporting memory pools
2853 extern int SgTypeUnknown_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2854 
2859 extern SgTypeUnknown* SgTypeUnknown_Current_Link; // = NULL;
2860 
2861 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2862 // This is was one of the things on the todo list (above).
2863 
2868 extern std::vector < unsigned char* > SgTypeUnknown_Memory_Block_List;
2869 /* */
2870 
2871 // DQ (4/6/2006): Newer code from Jochen
2872 // Methods to find the pointer to a global and local index
2873 SgTypeUnknown* SgTypeUnknown_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2874 SgTypeUnknown* SgTypeUnknown_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2875 
2876 // Methods for computing the total size of the memory pool. It actually returns the
2877 // size of the whole blocks allocated, no matter they contain valid pointers or not
2878 unsigned long SgTypeUnknown_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2879 void SgTypeUnknown_clearMemoryPool ( );
2880 void SgTypeUnknown_extendMemoryPoolForFileIO ( );
2881 unsigned long SgTypeUnknown_initializeStorageClassArray( SgTypeUnknownStorageClass *storageArray );
2882 void SgTypeUnknown_resetValidFreepointers( );
2883 unsigned long SgTypeUnknown_getNumberOfLastValidPointer();
2884 
2885 
2886 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2887 
2888 #include <semaphore.h>
2889 // DQ (9/21/2005): Static variables supporting memory pools
2896 extern int SgTypeChar_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2897 
2902 extern SgTypeChar* SgTypeChar_Current_Link; // = NULL;
2903 
2904 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2905 // This is was one of the things on the todo list (above).
2906 
2911 extern std::vector < unsigned char* > SgTypeChar_Memory_Block_List;
2912 /* */
2913 
2914 // DQ (4/6/2006): Newer code from Jochen
2915 // Methods to find the pointer to a global and local index
2916 SgTypeChar* SgTypeChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2917 SgTypeChar* SgTypeChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2918 
2919 // Methods for computing the total size of the memory pool. It actually returns the
2920 // size of the whole blocks allocated, no matter they contain valid pointers or not
2921 unsigned long SgTypeChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2922 void SgTypeChar_clearMemoryPool ( );
2923 void SgTypeChar_extendMemoryPoolForFileIO ( );
2924 unsigned long SgTypeChar_initializeStorageClassArray( SgTypeCharStorageClass *storageArray );
2925 void SgTypeChar_resetValidFreepointers( );
2926 unsigned long SgTypeChar_getNumberOfLastValidPointer();
2927 
2928 
2929 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2930 
2931 #include <semaphore.h>
2932 // DQ (9/21/2005): Static variables supporting memory pools
2939 extern int SgTypeSignedChar_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2940 
2945 extern SgTypeSignedChar* SgTypeSignedChar_Current_Link; // = NULL;
2946 
2947 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2948 // This is was one of the things on the todo list (above).
2949 
2954 extern std::vector < unsigned char* > SgTypeSignedChar_Memory_Block_List;
2955 /* */
2956 
2957 // DQ (4/6/2006): Newer code from Jochen
2958 // Methods to find the pointer to a global and local index
2959 SgTypeSignedChar* SgTypeSignedChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
2960 SgTypeSignedChar* SgTypeSignedChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
2961 
2962 // Methods for computing the total size of the memory pool. It actually returns the
2963 // size of the whole blocks allocated, no matter they contain valid pointers or not
2964 unsigned long SgTypeSignedChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
2965 void SgTypeSignedChar_clearMemoryPool ( );
2966 void SgTypeSignedChar_extendMemoryPoolForFileIO ( );
2967 unsigned long SgTypeSignedChar_initializeStorageClassArray( SgTypeSignedCharStorageClass *storageArray );
2968 void SgTypeSignedChar_resetValidFreepointers( );
2969 unsigned long SgTypeSignedChar_getNumberOfLastValidPointer();
2970 
2971 
2972 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
2973 
2974 #include <semaphore.h>
2975 // DQ (9/21/2005): Static variables supporting memory pools
2982 extern int SgTypeUnsignedChar_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
2983 
2988 extern SgTypeUnsignedChar* SgTypeUnsignedChar_Current_Link; // = NULL;
2989 
2990 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
2991 // This is was one of the things on the todo list (above).
2992 
2997 extern std::vector < unsigned char* > SgTypeUnsignedChar_Memory_Block_List;
2998 /* */
2999 
3000 // DQ (4/6/2006): Newer code from Jochen
3001 // Methods to find the pointer to a global and local index
3002 SgTypeUnsignedChar* SgTypeUnsignedChar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3003 SgTypeUnsignedChar* SgTypeUnsignedChar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3004 
3005 // Methods for computing the total size of the memory pool. It actually returns the
3006 // size of the whole blocks allocated, no matter they contain valid pointers or not
3007 unsigned long SgTypeUnsignedChar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3008 void SgTypeUnsignedChar_clearMemoryPool ( );
3009 void SgTypeUnsignedChar_extendMemoryPoolForFileIO ( );
3010 unsigned long SgTypeUnsignedChar_initializeStorageClassArray( SgTypeUnsignedCharStorageClass *storageArray );
3011 void SgTypeUnsignedChar_resetValidFreepointers( );
3012 unsigned long SgTypeUnsignedChar_getNumberOfLastValidPointer();
3013 
3014 
3015 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3016 
3017 #include <semaphore.h>
3018 // DQ (9/21/2005): Static variables supporting memory pools
3025 extern int SgTypeShort_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3026 
3031 extern SgTypeShort* SgTypeShort_Current_Link; // = NULL;
3032 
3033 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3034 // This is was one of the things on the todo list (above).
3035 
3040 extern std::vector < unsigned char* > SgTypeShort_Memory_Block_List;
3041 /* */
3042 
3043 // DQ (4/6/2006): Newer code from Jochen
3044 // Methods to find the pointer to a global and local index
3045 SgTypeShort* SgTypeShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3046 SgTypeShort* SgTypeShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3047 
3048 // Methods for computing the total size of the memory pool. It actually returns the
3049 // size of the whole blocks allocated, no matter they contain valid pointers or not
3050 unsigned long SgTypeShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3051 void SgTypeShort_clearMemoryPool ( );
3052 void SgTypeShort_extendMemoryPoolForFileIO ( );
3053 unsigned long SgTypeShort_initializeStorageClassArray( SgTypeShortStorageClass *storageArray );
3054 void SgTypeShort_resetValidFreepointers( );
3055 unsigned long SgTypeShort_getNumberOfLastValidPointer();
3056 
3057 
3058 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3059 
3060 #include <semaphore.h>
3061 // DQ (9/21/2005): Static variables supporting memory pools
3068 extern int SgTypeSignedShort_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3069 
3074 extern SgTypeSignedShort* SgTypeSignedShort_Current_Link; // = NULL;
3075 
3076 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3077 // This is was one of the things on the todo list (above).
3078 
3083 extern std::vector < unsigned char* > SgTypeSignedShort_Memory_Block_List;
3084 /* */
3085 
3086 // DQ (4/6/2006): Newer code from Jochen
3087 // Methods to find the pointer to a global and local index
3088 SgTypeSignedShort* SgTypeSignedShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3089 SgTypeSignedShort* SgTypeSignedShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3090 
3091 // Methods for computing the total size of the memory pool. It actually returns the
3092 // size of the whole blocks allocated, no matter they contain valid pointers or not
3093 unsigned long SgTypeSignedShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3094 void SgTypeSignedShort_clearMemoryPool ( );
3095 void SgTypeSignedShort_extendMemoryPoolForFileIO ( );
3096 unsigned long SgTypeSignedShort_initializeStorageClassArray( SgTypeSignedShortStorageClass *storageArray );
3097 void SgTypeSignedShort_resetValidFreepointers( );
3098 unsigned long SgTypeSignedShort_getNumberOfLastValidPointer();
3099 
3100 
3101 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3102 
3103 #include <semaphore.h>
3104 // DQ (9/21/2005): Static variables supporting memory pools
3111 extern int SgTypeUnsignedShort_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3112 
3117 extern SgTypeUnsignedShort* SgTypeUnsignedShort_Current_Link; // = NULL;
3118 
3119 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3120 // This is was one of the things on the todo list (above).
3121 
3126 extern std::vector < unsigned char* > SgTypeUnsignedShort_Memory_Block_List;
3127 /* */
3128 
3129 // DQ (4/6/2006): Newer code from Jochen
3130 // Methods to find the pointer to a global and local index
3131 SgTypeUnsignedShort* SgTypeUnsignedShort_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3132 SgTypeUnsignedShort* SgTypeUnsignedShort_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3133 
3134 // Methods for computing the total size of the memory pool. It actually returns the
3135 // size of the whole blocks allocated, no matter they contain valid pointers or not
3136 unsigned long SgTypeUnsignedShort_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3137 void SgTypeUnsignedShort_clearMemoryPool ( );
3138 void SgTypeUnsignedShort_extendMemoryPoolForFileIO ( );
3139 unsigned long SgTypeUnsignedShort_initializeStorageClassArray( SgTypeUnsignedShortStorageClass *storageArray );
3140 void SgTypeUnsignedShort_resetValidFreepointers( );
3141 unsigned long SgTypeUnsignedShort_getNumberOfLastValidPointer();
3142 
3143 
3144 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3145 
3146 #include <semaphore.h>
3147 // DQ (9/21/2005): Static variables supporting memory pools
3154 extern int SgTypeInt_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3155 
3160 extern SgTypeInt* SgTypeInt_Current_Link; // = NULL;
3161 
3162 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3163 // This is was one of the things on the todo list (above).
3164 
3169 extern std::vector < unsigned char* > SgTypeInt_Memory_Block_List;
3170 /* */
3171 
3172 // DQ (4/6/2006): Newer code from Jochen
3173 // Methods to find the pointer to a global and local index
3174 SgTypeInt* SgTypeInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3175 SgTypeInt* SgTypeInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3176 
3177 // Methods for computing the total size of the memory pool. It actually returns the
3178 // size of the whole blocks allocated, no matter they contain valid pointers or not
3179 unsigned long SgTypeInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3180 void SgTypeInt_clearMemoryPool ( );
3181 void SgTypeInt_extendMemoryPoolForFileIO ( );
3182 unsigned long SgTypeInt_initializeStorageClassArray( SgTypeIntStorageClass *storageArray );
3183 void SgTypeInt_resetValidFreepointers( );
3184 unsigned long SgTypeInt_getNumberOfLastValidPointer();
3185 
3186 
3187 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3188 
3189 #include <semaphore.h>
3190 // DQ (9/21/2005): Static variables supporting memory pools
3197 extern int SgTypeSignedInt_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3198 
3203 extern SgTypeSignedInt* SgTypeSignedInt_Current_Link; // = NULL;
3204 
3205 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3206 // This is was one of the things on the todo list (above).
3207 
3212 extern std::vector < unsigned char* > SgTypeSignedInt_Memory_Block_List;
3213 /* */
3214 
3215 // DQ (4/6/2006): Newer code from Jochen
3216 // Methods to find the pointer to a global and local index
3217 SgTypeSignedInt* SgTypeSignedInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3218 SgTypeSignedInt* SgTypeSignedInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3219 
3220 // Methods for computing the total size of the memory pool. It actually returns the
3221 // size of the whole blocks allocated, no matter they contain valid pointers or not
3222 unsigned long SgTypeSignedInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3223 void SgTypeSignedInt_clearMemoryPool ( );
3224 void SgTypeSignedInt_extendMemoryPoolForFileIO ( );
3225 unsigned long SgTypeSignedInt_initializeStorageClassArray( SgTypeSignedIntStorageClass *storageArray );
3226 void SgTypeSignedInt_resetValidFreepointers( );
3227 unsigned long SgTypeSignedInt_getNumberOfLastValidPointer();
3228 
3229 
3230 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3231 
3232 #include <semaphore.h>
3233 // DQ (9/21/2005): Static variables supporting memory pools
3240 extern int SgTypeUnsignedInt_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3241 
3246 extern SgTypeUnsignedInt* SgTypeUnsignedInt_Current_Link; // = NULL;
3247 
3248 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3249 // This is was one of the things on the todo list (above).
3250 
3255 extern std::vector < unsigned char* > SgTypeUnsignedInt_Memory_Block_List;
3256 /* */
3257 
3258 // DQ (4/6/2006): Newer code from Jochen
3259 // Methods to find the pointer to a global and local index
3260 SgTypeUnsignedInt* SgTypeUnsignedInt_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3261 SgTypeUnsignedInt* SgTypeUnsignedInt_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3262 
3263 // Methods for computing the total size of the memory pool. It actually returns the
3264 // size of the whole blocks allocated, no matter they contain valid pointers or not
3265 unsigned long SgTypeUnsignedInt_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3266 void SgTypeUnsignedInt_clearMemoryPool ( );
3267 void SgTypeUnsignedInt_extendMemoryPoolForFileIO ( );
3268 unsigned long SgTypeUnsignedInt_initializeStorageClassArray( SgTypeUnsignedIntStorageClass *storageArray );
3269 void SgTypeUnsignedInt_resetValidFreepointers( );
3270 unsigned long SgTypeUnsignedInt_getNumberOfLastValidPointer();
3271 
3272 
3273 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3274 
3275 #include <semaphore.h>
3276 // DQ (9/21/2005): Static variables supporting memory pools
3283 extern int SgTypeLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3284 
3289 extern SgTypeLong* SgTypeLong_Current_Link; // = NULL;
3290 
3291 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3292 // This is was one of the things on the todo list (above).
3293 
3298 extern std::vector < unsigned char* > SgTypeLong_Memory_Block_List;
3299 /* */
3300 
3301 // DQ (4/6/2006): Newer code from Jochen
3302 // Methods to find the pointer to a global and local index
3303 SgTypeLong* SgTypeLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3304 SgTypeLong* SgTypeLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3305 
3306 // Methods for computing the total size of the memory pool. It actually returns the
3307 // size of the whole blocks allocated, no matter they contain valid pointers or not
3308 unsigned long SgTypeLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3309 void SgTypeLong_clearMemoryPool ( );
3310 void SgTypeLong_extendMemoryPoolForFileIO ( );
3311 unsigned long SgTypeLong_initializeStorageClassArray( SgTypeLongStorageClass *storageArray );
3312 void SgTypeLong_resetValidFreepointers( );
3313 unsigned long SgTypeLong_getNumberOfLastValidPointer();
3314 
3315 
3316 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3317 
3318 #include <semaphore.h>
3319 // DQ (9/21/2005): Static variables supporting memory pools
3326 extern int SgTypeSignedLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3327 
3332 extern SgTypeSignedLong* SgTypeSignedLong_Current_Link; // = NULL;
3333 
3334 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3335 // This is was one of the things on the todo list (above).
3336 
3341 extern std::vector < unsigned char* > SgTypeSignedLong_Memory_Block_List;
3342 /* */
3343 
3344 // DQ (4/6/2006): Newer code from Jochen
3345 // Methods to find the pointer to a global and local index
3346 SgTypeSignedLong* SgTypeSignedLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3347 SgTypeSignedLong* SgTypeSignedLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3348 
3349 // Methods for computing the total size of the memory pool. It actually returns the
3350 // size of the whole blocks allocated, no matter they contain valid pointers or not
3351 unsigned long SgTypeSignedLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3352 void SgTypeSignedLong_clearMemoryPool ( );
3353 void SgTypeSignedLong_extendMemoryPoolForFileIO ( );
3354 unsigned long SgTypeSignedLong_initializeStorageClassArray( SgTypeSignedLongStorageClass *storageArray );
3355 void SgTypeSignedLong_resetValidFreepointers( );
3356 unsigned long SgTypeSignedLong_getNumberOfLastValidPointer();
3357 
3358 
3359 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3360 
3361 #include <semaphore.h>
3362 // DQ (9/21/2005): Static variables supporting memory pools
3369 extern int SgTypeUnsignedLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3370 
3375 extern SgTypeUnsignedLong* SgTypeUnsignedLong_Current_Link; // = NULL;
3376 
3377 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3378 // This is was one of the things on the todo list (above).
3379 
3384 extern std::vector < unsigned char* > SgTypeUnsignedLong_Memory_Block_List;
3385 /* */
3386 
3387 // DQ (4/6/2006): Newer code from Jochen
3388 // Methods to find the pointer to a global and local index
3389 SgTypeUnsignedLong* SgTypeUnsignedLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3390 SgTypeUnsignedLong* SgTypeUnsignedLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3391 
3392 // Methods for computing the total size of the memory pool. It actually returns the
3393 // size of the whole blocks allocated, no matter they contain valid pointers or not
3394 unsigned long SgTypeUnsignedLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3395 void SgTypeUnsignedLong_clearMemoryPool ( );
3396 void SgTypeUnsignedLong_extendMemoryPoolForFileIO ( );
3397 unsigned long SgTypeUnsignedLong_initializeStorageClassArray( SgTypeUnsignedLongStorageClass *storageArray );
3398 void SgTypeUnsignedLong_resetValidFreepointers( );
3399 unsigned long SgTypeUnsignedLong_getNumberOfLastValidPointer();
3400 
3401 
3402 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3403 
3404 #include <semaphore.h>
3405 // DQ (9/21/2005): Static variables supporting memory pools
3412 extern int SgTypeVoid_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3413 
3418 extern SgTypeVoid* SgTypeVoid_Current_Link; // = NULL;
3419 
3420 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3421 // This is was one of the things on the todo list (above).
3422 
3427 extern std::vector < unsigned char* > SgTypeVoid_Memory_Block_List;
3428 /* */
3429 
3430 // DQ (4/6/2006): Newer code from Jochen
3431 // Methods to find the pointer to a global and local index
3432 SgTypeVoid* SgTypeVoid_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3433 SgTypeVoid* SgTypeVoid_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3434 
3435 // Methods for computing the total size of the memory pool. It actually returns the
3436 // size of the whole blocks allocated, no matter they contain valid pointers or not
3437 unsigned long SgTypeVoid_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3438 void SgTypeVoid_clearMemoryPool ( );
3439 void SgTypeVoid_extendMemoryPoolForFileIO ( );
3440 unsigned long SgTypeVoid_initializeStorageClassArray( SgTypeVoidStorageClass *storageArray );
3441 void SgTypeVoid_resetValidFreepointers( );
3442 unsigned long SgTypeVoid_getNumberOfLastValidPointer();
3443 
3444 
3445 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3446 
3447 #include <semaphore.h>
3448 // DQ (9/21/2005): Static variables supporting memory pools
3455 extern int SgTypeGlobalVoid_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3456 
3461 extern SgTypeGlobalVoid* SgTypeGlobalVoid_Current_Link; // = NULL;
3462 
3463 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3464 // This is was one of the things on the todo list (above).
3465 
3470 extern std::vector < unsigned char* > SgTypeGlobalVoid_Memory_Block_List;
3471 /* */
3472 
3473 // DQ (4/6/2006): Newer code from Jochen
3474 // Methods to find the pointer to a global and local index
3475 SgTypeGlobalVoid* SgTypeGlobalVoid_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3476 SgTypeGlobalVoid* SgTypeGlobalVoid_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3477 
3478 // Methods for computing the total size of the memory pool. It actually returns the
3479 // size of the whole blocks allocated, no matter they contain valid pointers or not
3480 unsigned long SgTypeGlobalVoid_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3481 void SgTypeGlobalVoid_clearMemoryPool ( );
3482 void SgTypeGlobalVoid_extendMemoryPoolForFileIO ( );
3483 unsigned long SgTypeGlobalVoid_initializeStorageClassArray( SgTypeGlobalVoidStorageClass *storageArray );
3484 void SgTypeGlobalVoid_resetValidFreepointers( );
3485 unsigned long SgTypeGlobalVoid_getNumberOfLastValidPointer();
3486 
3487 
3488 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3489 
3490 #include <semaphore.h>
3491 // DQ (9/21/2005): Static variables supporting memory pools
3498 extern int SgTypeWchar_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3499 
3504 extern SgTypeWchar* SgTypeWchar_Current_Link; // = NULL;
3505 
3506 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3507 // This is was one of the things on the todo list (above).
3508 
3513 extern std::vector < unsigned char* > SgTypeWchar_Memory_Block_List;
3514 /* */
3515 
3516 // DQ (4/6/2006): Newer code from Jochen
3517 // Methods to find the pointer to a global and local index
3518 SgTypeWchar* SgTypeWchar_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3519 SgTypeWchar* SgTypeWchar_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3520 
3521 // Methods for computing the total size of the memory pool. It actually returns the
3522 // size of the whole blocks allocated, no matter they contain valid pointers or not
3523 unsigned long SgTypeWchar_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3524 void SgTypeWchar_clearMemoryPool ( );
3525 void SgTypeWchar_extendMemoryPoolForFileIO ( );
3526 unsigned long SgTypeWchar_initializeStorageClassArray( SgTypeWcharStorageClass *storageArray );
3527 void SgTypeWchar_resetValidFreepointers( );
3528 unsigned long SgTypeWchar_getNumberOfLastValidPointer();
3529 
3530 
3531 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3532 
3533 #include <semaphore.h>
3534 // DQ (9/21/2005): Static variables supporting memory pools
3541 extern int SgTypeFloat_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3542 
3547 extern SgTypeFloat* SgTypeFloat_Current_Link; // = NULL;
3548 
3549 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3550 // This is was one of the things on the todo list (above).
3551 
3556 extern std::vector < unsigned char* > SgTypeFloat_Memory_Block_List;
3557 /* */
3558 
3559 // DQ (4/6/2006): Newer code from Jochen
3560 // Methods to find the pointer to a global and local index
3561 SgTypeFloat* SgTypeFloat_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3562 SgTypeFloat* SgTypeFloat_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3563 
3564 // Methods for computing the total size of the memory pool. It actually returns the
3565 // size of the whole blocks allocated, no matter they contain valid pointers or not
3566 unsigned long SgTypeFloat_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3567 void SgTypeFloat_clearMemoryPool ( );
3568 void SgTypeFloat_extendMemoryPoolForFileIO ( );
3569 unsigned long SgTypeFloat_initializeStorageClassArray( SgTypeFloatStorageClass *storageArray );
3570 void SgTypeFloat_resetValidFreepointers( );
3571 unsigned long SgTypeFloat_getNumberOfLastValidPointer();
3572 
3573 
3574 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3575 
3576 #include <semaphore.h>
3577 // DQ (9/21/2005): Static variables supporting memory pools
3584 extern int SgTypeDouble_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3585 
3590 extern SgTypeDouble* SgTypeDouble_Current_Link; // = NULL;
3591 
3592 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3593 // This is was one of the things on the todo list (above).
3594 
3599 extern std::vector < unsigned char* > SgTypeDouble_Memory_Block_List;
3600 /* */
3601 
3602 // DQ (4/6/2006): Newer code from Jochen
3603 // Methods to find the pointer to a global and local index
3604 SgTypeDouble* SgTypeDouble_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3605 SgTypeDouble* SgTypeDouble_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3606 
3607 // Methods for computing the total size of the memory pool. It actually returns the
3608 // size of the whole blocks allocated, no matter they contain valid pointers or not
3609 unsigned long SgTypeDouble_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3610 void SgTypeDouble_clearMemoryPool ( );
3611 void SgTypeDouble_extendMemoryPoolForFileIO ( );
3612 unsigned long SgTypeDouble_initializeStorageClassArray( SgTypeDoubleStorageClass *storageArray );
3613 void SgTypeDouble_resetValidFreepointers( );
3614 unsigned long SgTypeDouble_getNumberOfLastValidPointer();
3615 
3616 
3617 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3618 
3619 #include <semaphore.h>
3620 // DQ (9/21/2005): Static variables supporting memory pools
3627 extern int SgTypeLongLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3628 
3633 extern SgTypeLongLong* SgTypeLongLong_Current_Link; // = NULL;
3634 
3635 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3636 // This is was one of the things on the todo list (above).
3637 
3642 extern std::vector < unsigned char* > SgTypeLongLong_Memory_Block_List;
3643 /* */
3644 
3645 // DQ (4/6/2006): Newer code from Jochen
3646 // Methods to find the pointer to a global and local index
3647 SgTypeLongLong* SgTypeLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3648 SgTypeLongLong* SgTypeLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3649 
3650 // Methods for computing the total size of the memory pool. It actually returns the
3651 // size of the whole blocks allocated, no matter they contain valid pointers or not
3652 unsigned long SgTypeLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3653 void SgTypeLongLong_clearMemoryPool ( );
3654 void SgTypeLongLong_extendMemoryPoolForFileIO ( );
3655 unsigned long SgTypeLongLong_initializeStorageClassArray( SgTypeLongLongStorageClass *storageArray );
3656 void SgTypeLongLong_resetValidFreepointers( );
3657 unsigned long SgTypeLongLong_getNumberOfLastValidPointer();
3658 
3659 
3660 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3661 
3662 #include <semaphore.h>
3663 // DQ (9/21/2005): Static variables supporting memory pools
3670 extern int SgTypeSignedLongLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3671 
3676 extern SgTypeSignedLongLong* SgTypeSignedLongLong_Current_Link; // = NULL;
3677 
3678 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3679 // This is was one of the things on the todo list (above).
3680 
3685 extern std::vector < unsigned char* > SgTypeSignedLongLong_Memory_Block_List;
3686 /* */
3687 
3688 // DQ (4/6/2006): Newer code from Jochen
3689 // Methods to find the pointer to a global and local index
3690 SgTypeSignedLongLong* SgTypeSignedLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3691 SgTypeSignedLongLong* SgTypeSignedLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3692 
3693 // Methods for computing the total size of the memory pool. It actually returns the
3694 // size of the whole blocks allocated, no matter they contain valid pointers or not
3695 unsigned long SgTypeSignedLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3696 void SgTypeSignedLongLong_clearMemoryPool ( );
3697 void SgTypeSignedLongLong_extendMemoryPoolForFileIO ( );
3698 unsigned long SgTypeSignedLongLong_initializeStorageClassArray( SgTypeSignedLongLongStorageClass *storageArray );
3699 void SgTypeSignedLongLong_resetValidFreepointers( );
3700 unsigned long SgTypeSignedLongLong_getNumberOfLastValidPointer();
3701 
3702 
3703 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3704 
3705 #include <semaphore.h>
3706 // DQ (9/21/2005): Static variables supporting memory pools
3713 extern int SgTypeUnsignedLongLong_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3714 
3719 extern SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_Current_Link; // = NULL;
3720 
3721 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3722 // This is was one of the things on the todo list (above).
3723 
3728 extern std::vector < unsigned char* > SgTypeUnsignedLongLong_Memory_Block_List;
3729 /* */
3730 
3731 // DQ (4/6/2006): Newer code from Jochen
3732 // Methods to find the pointer to a global and local index
3733 SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3734 SgTypeUnsignedLongLong* SgTypeUnsignedLongLong_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3735 
3736 // Methods for computing the total size of the memory pool. It actually returns the
3737 // size of the whole blocks allocated, no matter they contain valid pointers or not
3738 unsigned long SgTypeUnsignedLongLong_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3739 void SgTypeUnsignedLongLong_clearMemoryPool ( );
3740 void SgTypeUnsignedLongLong_extendMemoryPoolForFileIO ( );
3741 unsigned long SgTypeUnsignedLongLong_initializeStorageClassArray( SgTypeUnsignedLongLongStorageClass *storageArray );
3742 void SgTypeUnsignedLongLong_resetValidFreepointers( );
3743 unsigned long SgTypeUnsignedLongLong_getNumberOfLastValidPointer();
3744 
3745 
3746 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3747 
3748 #include <semaphore.h>
3749 // DQ (9/21/2005): Static variables supporting memory pools
3756 extern int SgTypeSigned128bitInteger_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3757 
3762 extern SgTypeSigned128bitInteger* SgTypeSigned128bitInteger_Current_Link; // = NULL;
3763 
3764 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3765 // This is was one of the things on the todo list (above).
3766 
3771 extern std::vector < unsigned char* > SgTypeSigned128bitInteger_Memory_Block_List;
3772 /* */
3773 
3774 // DQ (4/6/2006): Newer code from Jochen
3775 // Methods to find the pointer to a global and local index
3776 SgTypeSigned128bitInteger* SgTypeSigned128bitInteger_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3777 SgTypeSigned128bitInteger* SgTypeSigned128bitInteger_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3778 
3779 // Methods for computing the total size of the memory pool. It actually returns the
3780 // size of the whole blocks allocated, no matter they contain valid pointers or not
3781 unsigned long SgTypeSigned128bitInteger_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3782 void SgTypeSigned128bitInteger_clearMemoryPool ( );
3783 void SgTypeSigned128bitInteger_extendMemoryPoolForFileIO ( );
3784 unsigned long SgTypeSigned128bitInteger_initializeStorageClassArray( SgTypeSigned128bitIntegerStorageClass *storageArray );
3785 void SgTypeSigned128bitInteger_resetValidFreepointers( );
3786 unsigned long SgTypeSigned128bitInteger_getNumberOfLastValidPointer();
3787 
3788 
3789 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3790 
3791 #include <semaphore.h>
3792 // DQ (9/21/2005): Static variables supporting memory pools
3799 extern int SgTypeUnsigned128bitInteger_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3800 
3805 extern SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger_Current_Link; // = NULL;
3806 
3807 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3808 // This is was one of the things on the todo list (above).
3809 
3814 extern std::vector < unsigned char* > SgTypeUnsigned128bitInteger_Memory_Block_List;
3815 /* */
3816 
3817 // DQ (4/6/2006): Newer code from Jochen
3818 // Methods to find the pointer to a global and local index
3819 SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3820 SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3821 
3822 // Methods for computing the total size of the memory pool. It actually returns the
3823 // size of the whole blocks allocated, no matter they contain valid pointers or not
3824 unsigned long SgTypeUnsigned128bitInteger_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3825 void SgTypeUnsigned128bitInteger_clearMemoryPool ( );
3826 void SgTypeUnsigned128bitInteger_extendMemoryPoolForFileIO ( );
3827 unsigned long SgTypeUnsigned128bitInteger_initializeStorageClassArray( SgTypeUnsigned128bitIntegerStorageClass *storageArray );
3828 void SgTypeUnsigned128bitInteger_resetValidFreepointers( );
3829 unsigned long SgTypeUnsigned128bitInteger_getNumberOfLastValidPointer();
3830 
3831 
3832 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3833 
3834 #include <semaphore.h>
3835 // DQ (9/21/2005): Static variables supporting memory pools
3842 extern int SgTypeLongDouble_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3843 
3848 extern SgTypeLongDouble* SgTypeLongDouble_Current_Link; // = NULL;
3849 
3850 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3851 // This is was one of the things on the todo list (above).
3852 
3857 extern std::vector < unsigned char* > SgTypeLongDouble_Memory_Block_List;
3858 /* */
3859 
3860 // DQ (4/6/2006): Newer code from Jochen
3861 // Methods to find the pointer to a global and local index
3862 SgTypeLongDouble* SgTypeLongDouble_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3863 SgTypeLongDouble* SgTypeLongDouble_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3864 
3865 // Methods for computing the total size of the memory pool. It actually returns the
3866 // size of the whole blocks allocated, no matter they contain valid pointers or not
3867 unsigned long SgTypeLongDouble_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3868 void SgTypeLongDouble_clearMemoryPool ( );
3869 void SgTypeLongDouble_extendMemoryPoolForFileIO ( );
3870 unsigned long SgTypeLongDouble_initializeStorageClassArray( SgTypeLongDoubleStorageClass *storageArray );
3871 void SgTypeLongDouble_resetValidFreepointers( );
3872 unsigned long SgTypeLongDouble_getNumberOfLastValidPointer();
3873 
3874 
3875 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3876 
3877 #include <semaphore.h>
3878 // DQ (9/21/2005): Static variables supporting memory pools
3885 extern int SgTypeString_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3886 
3891 extern SgTypeString* SgTypeString_Current_Link; // = NULL;
3892 
3893 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3894 // This is was one of the things on the todo list (above).
3895 
3900 extern std::vector < unsigned char* > SgTypeString_Memory_Block_List;
3901 /* */
3902 
3903 // DQ (4/6/2006): Newer code from Jochen
3904 // Methods to find the pointer to a global and local index
3905 SgTypeString* SgTypeString_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3906 SgTypeString* SgTypeString_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3907 
3908 // Methods for computing the total size of the memory pool. It actually returns the
3909 // size of the whole blocks allocated, no matter they contain valid pointers or not
3910 unsigned long SgTypeString_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3911 void SgTypeString_clearMemoryPool ( );
3912 void SgTypeString_extendMemoryPoolForFileIO ( );
3913 unsigned long SgTypeString_initializeStorageClassArray( SgTypeStringStorageClass *storageArray );
3914 void SgTypeString_resetValidFreepointers( );
3915 unsigned long SgTypeString_getNumberOfLastValidPointer();
3916 
3917 
3918 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3919 
3920 #include <semaphore.h>
3921 // DQ (9/21/2005): Static variables supporting memory pools
3928 extern int SgTypeBool_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3929 
3934 extern SgTypeBool* SgTypeBool_Current_Link; // = NULL;
3935 
3936 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3937 // This is was one of the things on the todo list (above).
3938 
3943 extern std::vector < unsigned char* > SgTypeBool_Memory_Block_List;
3944 /* */
3945 
3946 // DQ (4/6/2006): Newer code from Jochen
3947 // Methods to find the pointer to a global and local index
3948 SgTypeBool* SgTypeBool_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3949 SgTypeBool* SgTypeBool_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3950 
3951 // Methods for computing the total size of the memory pool. It actually returns the
3952 // size of the whole blocks allocated, no matter they contain valid pointers or not
3953 unsigned long SgTypeBool_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3954 void SgTypeBool_clearMemoryPool ( );
3955 void SgTypeBool_extendMemoryPoolForFileIO ( );
3956 unsigned long SgTypeBool_initializeStorageClassArray( SgTypeBoolStorageClass *storageArray );
3957 void SgTypeBool_resetValidFreepointers( );
3958 unsigned long SgTypeBool_getNumberOfLastValidPointer();
3959 
3960 
3961 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
3962 
3963 #include <semaphore.h>
3964 // DQ (9/21/2005): Static variables supporting memory pools
3971 extern int SgPointerType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
3972 
3977 extern SgPointerType* SgPointerType_Current_Link; // = NULL;
3978 
3979 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
3980 // This is was one of the things on the todo list (above).
3981 
3986 extern std::vector < unsigned char* > SgPointerType_Memory_Block_List;
3987 /* */
3988 
3989 // DQ (4/6/2006): Newer code from Jochen
3990 // Methods to find the pointer to a global and local index
3991 SgPointerType* SgPointerType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
3992 SgPointerType* SgPointerType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
3993 
3994 // Methods for computing the total size of the memory pool. It actually returns the
3995 // size of the whole blocks allocated, no matter they contain valid pointers or not
3996 unsigned long SgPointerType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
3997 void SgPointerType_clearMemoryPool ( );
3998 void SgPointerType_extendMemoryPoolForFileIO ( );
3999 unsigned long SgPointerType_initializeStorageClassArray( SgPointerTypeStorageClass *storageArray );
4000 void SgPointerType_resetValidFreepointers( );
4001 unsigned long SgPointerType_getNumberOfLastValidPointer();
4002 
4003 
4004 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4005 
4006 #include <semaphore.h>
4007 // DQ (9/21/2005): Static variables supporting memory pools
4014 extern int SgPointerMemberType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4015 
4020 extern SgPointerMemberType* SgPointerMemberType_Current_Link; // = NULL;
4021 
4022 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4023 // This is was one of the things on the todo list (above).
4024 
4029 extern std::vector < unsigned char* > SgPointerMemberType_Memory_Block_List;
4030 /* */
4031 
4032 // DQ (4/6/2006): Newer code from Jochen
4033 // Methods to find the pointer to a global and local index
4034 SgPointerMemberType* SgPointerMemberType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4035 SgPointerMemberType* SgPointerMemberType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4036 
4037 // Methods for computing the total size of the memory pool. It actually returns the
4038 // size of the whole blocks allocated, no matter they contain valid pointers or not
4039 unsigned long SgPointerMemberType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4040 void SgPointerMemberType_clearMemoryPool ( );
4041 void SgPointerMemberType_extendMemoryPoolForFileIO ( );
4042 unsigned long SgPointerMemberType_initializeStorageClassArray( SgPointerMemberTypeStorageClass *storageArray );
4043 void SgPointerMemberType_resetValidFreepointers( );
4044 unsigned long SgPointerMemberType_getNumberOfLastValidPointer();
4045 
4046 
4047 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4048 
4049 #include <semaphore.h>
4050 // DQ (9/21/2005): Static variables supporting memory pools
4057 extern int SgReferenceType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4058 
4063 extern SgReferenceType* SgReferenceType_Current_Link; // = NULL;
4064 
4065 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4066 // This is was one of the things on the todo list (above).
4067 
4072 extern std::vector < unsigned char* > SgReferenceType_Memory_Block_List;
4073 /* */
4074 
4075 // DQ (4/6/2006): Newer code from Jochen
4076 // Methods to find the pointer to a global and local index
4077 SgReferenceType* SgReferenceType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4078 SgReferenceType* SgReferenceType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4079 
4080 // Methods for computing the total size of the memory pool. It actually returns the
4081 // size of the whole blocks allocated, no matter they contain valid pointers or not
4082 unsigned long SgReferenceType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4083 void SgReferenceType_clearMemoryPool ( );
4084 void SgReferenceType_extendMemoryPoolForFileIO ( );
4085 unsigned long SgReferenceType_initializeStorageClassArray( SgReferenceTypeStorageClass *storageArray );
4086 void SgReferenceType_resetValidFreepointers( );
4087 unsigned long SgReferenceType_getNumberOfLastValidPointer();
4088 
4089 
4090 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4091 
4092 #include <semaphore.h>
4093 // DQ (9/21/2005): Static variables supporting memory pools
4100 extern int SgNamedType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4101 
4106 extern SgNamedType* SgNamedType_Current_Link; // = NULL;
4107 
4108 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4109 // This is was one of the things on the todo list (above).
4110 
4115 extern std::vector < unsigned char* > SgNamedType_Memory_Block_List;
4116 /* */
4117 
4118 // DQ (4/6/2006): Newer code from Jochen
4119 // Methods to find the pointer to a global and local index
4120 SgNamedType* SgNamedType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4121 SgNamedType* SgNamedType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4122 
4123 // Methods for computing the total size of the memory pool. It actually returns the
4124 // size of the whole blocks allocated, no matter they contain valid pointers or not
4125 unsigned long SgNamedType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4126 void SgNamedType_clearMemoryPool ( );
4127 void SgNamedType_extendMemoryPoolForFileIO ( );
4128 unsigned long SgNamedType_initializeStorageClassArray( SgNamedTypeStorageClass *storageArray );
4129 void SgNamedType_resetValidFreepointers( );
4130 unsigned long SgNamedType_getNumberOfLastValidPointer();
4131 
4132 
4133 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4134 
4135 #include <semaphore.h>
4136 // DQ (9/21/2005): Static variables supporting memory pools
4143 extern int SgClassType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4144 
4149 extern SgClassType* SgClassType_Current_Link; // = NULL;
4150 
4151 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4152 // This is was one of the things on the todo list (above).
4153 
4158 extern std::vector < unsigned char* > SgClassType_Memory_Block_List;
4159 /* */
4160 
4161 // DQ (4/6/2006): Newer code from Jochen
4162 // Methods to find the pointer to a global and local index
4163 SgClassType* SgClassType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4164 SgClassType* SgClassType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4165 
4166 // Methods for computing the total size of the memory pool. It actually returns the
4167 // size of the whole blocks allocated, no matter they contain valid pointers or not
4168 unsigned long SgClassType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4169 void SgClassType_clearMemoryPool ( );
4170 void SgClassType_extendMemoryPoolForFileIO ( );
4171 unsigned long SgClassType_initializeStorageClassArray( SgClassTypeStorageClass *storageArray );
4172 void SgClassType_resetValidFreepointers( );
4173 unsigned long SgClassType_getNumberOfLastValidPointer();
4174 
4175 
4176 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4177 
4178 #include <semaphore.h>
4179 // DQ (9/21/2005): Static variables supporting memory pools
4186 extern int SgJavaParameterType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4187 
4192 extern SgJavaParameterType* SgJavaParameterType_Current_Link; // = NULL;
4193 
4194 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4195 // This is was one of the things on the todo list (above).
4196 
4201 extern std::vector < unsigned char* > SgJavaParameterType_Memory_Block_List;
4202 /* */
4203 
4204 // DQ (4/6/2006): Newer code from Jochen
4205 // Methods to find the pointer to a global and local index
4206 SgJavaParameterType* SgJavaParameterType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4207 SgJavaParameterType* SgJavaParameterType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4208 
4209 // Methods for computing the total size of the memory pool. It actually returns the
4210 // size of the whole blocks allocated, no matter they contain valid pointers or not
4211 unsigned long SgJavaParameterType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4212 void SgJavaParameterType_clearMemoryPool ( );
4213 void SgJavaParameterType_extendMemoryPoolForFileIO ( );
4214 unsigned long SgJavaParameterType_initializeStorageClassArray( SgJavaParameterTypeStorageClass *storageArray );
4215 void SgJavaParameterType_resetValidFreepointers( );
4216 unsigned long SgJavaParameterType_getNumberOfLastValidPointer();
4217 
4218 
4219 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4220 
4221 #include <semaphore.h>
4222 // DQ (9/21/2005): Static variables supporting memory pools
4229 extern int SgJavaParameterizedType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4230 
4235 extern SgJavaParameterizedType* SgJavaParameterizedType_Current_Link; // = NULL;
4236 
4237 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4238 // This is was one of the things on the todo list (above).
4239 
4244 extern std::vector < unsigned char* > SgJavaParameterizedType_Memory_Block_List;
4245 /* */
4246 
4247 // DQ (4/6/2006): Newer code from Jochen
4248 // Methods to find the pointer to a global and local index
4249 SgJavaParameterizedType* SgJavaParameterizedType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4250 SgJavaParameterizedType* SgJavaParameterizedType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4251 
4252 // Methods for computing the total size of the memory pool. It actually returns the
4253 // size of the whole blocks allocated, no matter they contain valid pointers or not
4254 unsigned long SgJavaParameterizedType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4255 void SgJavaParameterizedType_clearMemoryPool ( );
4256 void SgJavaParameterizedType_extendMemoryPoolForFileIO ( );
4257 unsigned long SgJavaParameterizedType_initializeStorageClassArray( SgJavaParameterizedTypeStorageClass *storageArray );
4258 void SgJavaParameterizedType_resetValidFreepointers( );
4259 unsigned long SgJavaParameterizedType_getNumberOfLastValidPointer();
4260 
4261 
4262 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4263 
4264 #include <semaphore.h>
4265 // DQ (9/21/2005): Static variables supporting memory pools
4272 extern int SgJavaQualifiedType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4273 
4278 extern SgJavaQualifiedType* SgJavaQualifiedType_Current_Link; // = NULL;
4279 
4280 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4281 // This is was one of the things on the todo list (above).
4282 
4287 extern std::vector < unsigned char* > SgJavaQualifiedType_Memory_Block_List;
4288 /* */
4289 
4290 // DQ (4/6/2006): Newer code from Jochen
4291 // Methods to find the pointer to a global and local index
4292 SgJavaQualifiedType* SgJavaQualifiedType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4293 SgJavaQualifiedType* SgJavaQualifiedType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4294 
4295 // Methods for computing the total size of the memory pool. It actually returns the
4296 // size of the whole blocks allocated, no matter they contain valid pointers or not
4297 unsigned long SgJavaQualifiedType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4298 void SgJavaQualifiedType_clearMemoryPool ( );
4299 void SgJavaQualifiedType_extendMemoryPoolForFileIO ( );
4300 unsigned long SgJavaQualifiedType_initializeStorageClassArray( SgJavaQualifiedTypeStorageClass *storageArray );
4301 void SgJavaQualifiedType_resetValidFreepointers( );
4302 unsigned long SgJavaQualifiedType_getNumberOfLastValidPointer();
4303 
4304 
4305 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4306 
4307 #include <semaphore.h>
4308 // DQ (9/21/2005): Static variables supporting memory pools
4315 extern int SgEnumType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4316 
4321 extern SgEnumType* SgEnumType_Current_Link; // = NULL;
4322 
4323 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4324 // This is was one of the things on the todo list (above).
4325 
4330 extern std::vector < unsigned char* > SgEnumType_Memory_Block_List;
4331 /* */
4332 
4333 // DQ (4/6/2006): Newer code from Jochen
4334 // Methods to find the pointer to a global and local index
4335 SgEnumType* SgEnumType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4336 SgEnumType* SgEnumType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4337 
4338 // Methods for computing the total size of the memory pool. It actually returns the
4339 // size of the whole blocks allocated, no matter they contain valid pointers or not
4340 unsigned long SgEnumType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4341 void SgEnumType_clearMemoryPool ( );
4342 void SgEnumType_extendMemoryPoolForFileIO ( );
4343 unsigned long SgEnumType_initializeStorageClassArray( SgEnumTypeStorageClass *storageArray );
4344 void SgEnumType_resetValidFreepointers( );
4345 unsigned long SgEnumType_getNumberOfLastValidPointer();
4346 
4347 
4348 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4349 
4350 #include <semaphore.h>
4351 // DQ (9/21/2005): Static variables supporting memory pools
4358 extern int SgTypedefType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4359 
4364 extern SgTypedefType* SgTypedefType_Current_Link; // = NULL;
4365 
4366 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4367 // This is was one of the things on the todo list (above).
4368 
4373 extern std::vector < unsigned char* > SgTypedefType_Memory_Block_List;
4374 /* */
4375 
4376 // DQ (4/6/2006): Newer code from Jochen
4377 // Methods to find the pointer to a global and local index
4378 SgTypedefType* SgTypedefType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4379 SgTypedefType* SgTypedefType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4380 
4381 // Methods for computing the total size of the memory pool. It actually returns the
4382 // size of the whole blocks allocated, no matter they contain valid pointers or not
4383 unsigned long SgTypedefType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4384 void SgTypedefType_clearMemoryPool ( );
4385 void SgTypedefType_extendMemoryPoolForFileIO ( );
4386 unsigned long SgTypedefType_initializeStorageClassArray( SgTypedefTypeStorageClass *storageArray );
4387 void SgTypedefType_resetValidFreepointers( );
4388 unsigned long SgTypedefType_getNumberOfLastValidPointer();
4389 
4390 
4391 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4392 
4393 #include <semaphore.h>
4394 // DQ (9/21/2005): Static variables supporting memory pools
4401 extern int SgJavaWildcardType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4402 
4407 extern SgJavaWildcardType* SgJavaWildcardType_Current_Link; // = NULL;
4408 
4409 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4410 // This is was one of the things on the todo list (above).
4411 
4416 extern std::vector < unsigned char* > SgJavaWildcardType_Memory_Block_List;
4417 /* */
4418 
4419 // DQ (4/6/2006): Newer code from Jochen
4420 // Methods to find the pointer to a global and local index
4421 SgJavaWildcardType* SgJavaWildcardType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4422 SgJavaWildcardType* SgJavaWildcardType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4423 
4424 // Methods for computing the total size of the memory pool. It actually returns the
4425 // size of the whole blocks allocated, no matter they contain valid pointers or not
4426 unsigned long SgJavaWildcardType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4427 void SgJavaWildcardType_clearMemoryPool ( );
4428 void SgJavaWildcardType_extendMemoryPoolForFileIO ( );
4429 unsigned long SgJavaWildcardType_initializeStorageClassArray( SgJavaWildcardTypeStorageClass *storageArray );
4430 void SgJavaWildcardType_resetValidFreepointers( );
4431 unsigned long SgJavaWildcardType_getNumberOfLastValidPointer();
4432 
4433 
4434 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4435 
4436 #include <semaphore.h>
4437 // DQ (9/21/2005): Static variables supporting memory pools
4444 extern int SgModifierType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4445 
4450 extern SgModifierType* SgModifierType_Current_Link; // = NULL;
4451 
4452 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4453 // This is was one of the things on the todo list (above).
4454 
4459 extern std::vector < unsigned char* > SgModifierType_Memory_Block_List;
4460 /* */
4461 
4462 // DQ (4/6/2006): Newer code from Jochen
4463 // Methods to find the pointer to a global and local index
4464 SgModifierType* SgModifierType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4465 SgModifierType* SgModifierType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4466 
4467 // Methods for computing the total size of the memory pool. It actually returns the
4468 // size of the whole blocks allocated, no matter they contain valid pointers or not
4469 unsigned long SgModifierType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4470 void SgModifierType_clearMemoryPool ( );
4471 void SgModifierType_extendMemoryPoolForFileIO ( );
4472 unsigned long SgModifierType_initializeStorageClassArray( SgModifierTypeStorageClass *storageArray );
4473 void SgModifierType_resetValidFreepointers( );
4474 unsigned long SgModifierType_getNumberOfLastValidPointer();
4475 
4476 
4477 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4478 
4479 #include <semaphore.h>
4480 // DQ (9/21/2005): Static variables supporting memory pools
4487 extern int SgFunctionType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4488 
4493 extern SgFunctionType* SgFunctionType_Current_Link; // = NULL;
4494 
4495 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4496 // This is was one of the things on the todo list (above).
4497 
4502 extern std::vector < unsigned char* > SgFunctionType_Memory_Block_List;
4503 /* */
4504 
4505 // DQ (4/6/2006): Newer code from Jochen
4506 // Methods to find the pointer to a global and local index
4507 SgFunctionType* SgFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4508 SgFunctionType* SgFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4509 
4510 // Methods for computing the total size of the memory pool. It actually returns the
4511 // size of the whole blocks allocated, no matter they contain valid pointers or not
4512 unsigned long SgFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4513 void SgFunctionType_clearMemoryPool ( );
4514 void SgFunctionType_extendMemoryPoolForFileIO ( );
4515 unsigned long SgFunctionType_initializeStorageClassArray( SgFunctionTypeStorageClass *storageArray );
4516 void SgFunctionType_resetValidFreepointers( );
4517 unsigned long SgFunctionType_getNumberOfLastValidPointer();
4518 
4519 
4520 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4521 
4522 #include <semaphore.h>
4523 // DQ (9/21/2005): Static variables supporting memory pools
4530 extern int SgMemberFunctionType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4531 
4536 extern SgMemberFunctionType* SgMemberFunctionType_Current_Link; // = NULL;
4537 
4538 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4539 // This is was one of the things on the todo list (above).
4540 
4545 extern std::vector < unsigned char* > SgMemberFunctionType_Memory_Block_List;
4546 /* */
4547 
4548 // DQ (4/6/2006): Newer code from Jochen
4549 // Methods to find the pointer to a global and local index
4550 SgMemberFunctionType* SgMemberFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4551 SgMemberFunctionType* SgMemberFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4552 
4553 // Methods for computing the total size of the memory pool. It actually returns the
4554 // size of the whole blocks allocated, no matter they contain valid pointers or not
4555 unsigned long SgMemberFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4556 void SgMemberFunctionType_clearMemoryPool ( );
4557 void SgMemberFunctionType_extendMemoryPoolForFileIO ( );
4558 unsigned long SgMemberFunctionType_initializeStorageClassArray( SgMemberFunctionTypeStorageClass *storageArray );
4559 void SgMemberFunctionType_resetValidFreepointers( );
4560 unsigned long SgMemberFunctionType_getNumberOfLastValidPointer();
4561 
4562 
4563 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4564 
4565 #include <semaphore.h>
4566 // DQ (9/21/2005): Static variables supporting memory pools
4573 extern int SgPartialFunctionType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4574 
4579 extern SgPartialFunctionType* SgPartialFunctionType_Current_Link; // = NULL;
4580 
4581 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4582 // This is was one of the things on the todo list (above).
4583 
4588 extern std::vector < unsigned char* > SgPartialFunctionType_Memory_Block_List;
4589 /* */
4590 
4591 // DQ (4/6/2006): Newer code from Jochen
4592 // Methods to find the pointer to a global and local index
4593 SgPartialFunctionType* SgPartialFunctionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4594 SgPartialFunctionType* SgPartialFunctionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4595 
4596 // Methods for computing the total size of the memory pool. It actually returns the
4597 // size of the whole blocks allocated, no matter they contain valid pointers or not
4598 unsigned long SgPartialFunctionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4599 void SgPartialFunctionType_clearMemoryPool ( );
4600 void SgPartialFunctionType_extendMemoryPoolForFileIO ( );
4601 unsigned long SgPartialFunctionType_initializeStorageClassArray( SgPartialFunctionTypeStorageClass *storageArray );
4602 void SgPartialFunctionType_resetValidFreepointers( );
4603 unsigned long SgPartialFunctionType_getNumberOfLastValidPointer();
4604 
4605 
4606 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4607 
4608 #include <semaphore.h>
4609 // DQ (9/21/2005): Static variables supporting memory pools
4616 extern int SgPartialFunctionModifierType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4617 
4622 extern SgPartialFunctionModifierType* SgPartialFunctionModifierType_Current_Link; // = NULL;
4623 
4624 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4625 // This is was one of the things on the todo list (above).
4626 
4631 extern std::vector < unsigned char* > SgPartialFunctionModifierType_Memory_Block_List;
4632 /* */
4633 
4634 // DQ (4/6/2006): Newer code from Jochen
4635 // Methods to find the pointer to a global and local index
4636 SgPartialFunctionModifierType* SgPartialFunctionModifierType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4637 SgPartialFunctionModifierType* SgPartialFunctionModifierType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4638 
4639 // Methods for computing the total size of the memory pool. It actually returns the
4640 // size of the whole blocks allocated, no matter they contain valid pointers or not
4641 unsigned long SgPartialFunctionModifierType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4642 void SgPartialFunctionModifierType_clearMemoryPool ( );
4643 void SgPartialFunctionModifierType_extendMemoryPoolForFileIO ( );
4644 unsigned long SgPartialFunctionModifierType_initializeStorageClassArray( SgPartialFunctionModifierTypeStorageClass *storageArray );
4645 void SgPartialFunctionModifierType_resetValidFreepointers( );
4646 unsigned long SgPartialFunctionModifierType_getNumberOfLastValidPointer();
4647 
4648 
4649 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4650 
4651 #include <semaphore.h>
4652 // DQ (9/21/2005): Static variables supporting memory pools
4659 extern int SgArrayType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4660 
4665 extern SgArrayType* SgArrayType_Current_Link; // = NULL;
4666 
4667 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4668 // This is was one of the things on the todo list (above).
4669 
4674 extern std::vector < unsigned char* > SgArrayType_Memory_Block_List;
4675 /* */
4676 
4677 // DQ (4/6/2006): Newer code from Jochen
4678 // Methods to find the pointer to a global and local index
4679 SgArrayType* SgArrayType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4680 SgArrayType* SgArrayType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4681 
4682 // Methods for computing the total size of the memory pool. It actually returns the
4683 // size of the whole blocks allocated, no matter they contain valid pointers or not
4684 unsigned long SgArrayType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4685 void SgArrayType_clearMemoryPool ( );
4686 void SgArrayType_extendMemoryPoolForFileIO ( );
4687 unsigned long SgArrayType_initializeStorageClassArray( SgArrayTypeStorageClass *storageArray );
4688 void SgArrayType_resetValidFreepointers( );
4689 unsigned long SgArrayType_getNumberOfLastValidPointer();
4690 
4691 
4692 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4693 
4694 #include <semaphore.h>
4695 // DQ (9/21/2005): Static variables supporting memory pools
4702 extern int SgTypeEllipse_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4703 
4708 extern SgTypeEllipse* SgTypeEllipse_Current_Link; // = NULL;
4709 
4710 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4711 // This is was one of the things on the todo list (above).
4712 
4717 extern std::vector < unsigned char* > SgTypeEllipse_Memory_Block_List;
4718 /* */
4719 
4720 // DQ (4/6/2006): Newer code from Jochen
4721 // Methods to find the pointer to a global and local index
4722 SgTypeEllipse* SgTypeEllipse_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4723 SgTypeEllipse* SgTypeEllipse_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4724 
4725 // Methods for computing the total size of the memory pool. It actually returns the
4726 // size of the whole blocks allocated, no matter they contain valid pointers or not
4727 unsigned long SgTypeEllipse_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4728 void SgTypeEllipse_clearMemoryPool ( );
4729 void SgTypeEllipse_extendMemoryPoolForFileIO ( );
4730 unsigned long SgTypeEllipse_initializeStorageClassArray( SgTypeEllipseStorageClass *storageArray );
4731 void SgTypeEllipse_resetValidFreepointers( );
4732 unsigned long SgTypeEllipse_getNumberOfLastValidPointer();
4733 
4734 
4735 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4736 
4737 #include <semaphore.h>
4738 // DQ (9/21/2005): Static variables supporting memory pools
4745 extern int SgTemplateType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4746 
4751 extern SgTemplateType* SgTemplateType_Current_Link; // = NULL;
4752 
4753 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4754 // This is was one of the things on the todo list (above).
4755 
4760 extern std::vector < unsigned char* > SgTemplateType_Memory_Block_List;
4761 /* */
4762 
4763 // DQ (4/6/2006): Newer code from Jochen
4764 // Methods to find the pointer to a global and local index
4765 SgTemplateType* SgTemplateType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4766 SgTemplateType* SgTemplateType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4767 
4768 // Methods for computing the total size of the memory pool. It actually returns the
4769 // size of the whole blocks allocated, no matter they contain valid pointers or not
4770 unsigned long SgTemplateType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4771 void SgTemplateType_clearMemoryPool ( );
4772 void SgTemplateType_extendMemoryPoolForFileIO ( );
4773 unsigned long SgTemplateType_initializeStorageClassArray( SgTemplateTypeStorageClass *storageArray );
4774 void SgTemplateType_resetValidFreepointers( );
4775 unsigned long SgTemplateType_getNumberOfLastValidPointer();
4776 
4777 
4778 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4779 
4780 #include <semaphore.h>
4781 // DQ (9/21/2005): Static variables supporting memory pools
4788 extern int SgQualifiedNameType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4789 
4794 extern SgQualifiedNameType* SgQualifiedNameType_Current_Link; // = NULL;
4795 
4796 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4797 // This is was one of the things on the todo list (above).
4798 
4803 extern std::vector < unsigned char* > SgQualifiedNameType_Memory_Block_List;
4804 /* */
4805 
4806 // DQ (4/6/2006): Newer code from Jochen
4807 // Methods to find the pointer to a global and local index
4808 SgQualifiedNameType* SgQualifiedNameType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4809 SgQualifiedNameType* SgQualifiedNameType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4810 
4811 // Methods for computing the total size of the memory pool. It actually returns the
4812 // size of the whole blocks allocated, no matter they contain valid pointers or not
4813 unsigned long SgQualifiedNameType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4814 void SgQualifiedNameType_clearMemoryPool ( );
4815 void SgQualifiedNameType_extendMemoryPoolForFileIO ( );
4816 unsigned long SgQualifiedNameType_initializeStorageClassArray( SgQualifiedNameTypeStorageClass *storageArray );
4817 void SgQualifiedNameType_resetValidFreepointers( );
4818 unsigned long SgQualifiedNameType_getNumberOfLastValidPointer();
4819 
4820 
4821 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4822 
4823 #include <semaphore.h>
4824 // DQ (9/21/2005): Static variables supporting memory pools
4831 extern int SgTypeComplex_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4832 
4837 extern SgTypeComplex* SgTypeComplex_Current_Link; // = NULL;
4838 
4839 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4840 // This is was one of the things on the todo list (above).
4841 
4846 extern std::vector < unsigned char* > SgTypeComplex_Memory_Block_List;
4847 /* */
4848 
4849 // DQ (4/6/2006): Newer code from Jochen
4850 // Methods to find the pointer to a global and local index
4851 SgTypeComplex* SgTypeComplex_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4852 SgTypeComplex* SgTypeComplex_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4853 
4854 // Methods for computing the total size of the memory pool. It actually returns the
4855 // size of the whole blocks allocated, no matter they contain valid pointers or not
4856 unsigned long SgTypeComplex_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4857 void SgTypeComplex_clearMemoryPool ( );
4858 void SgTypeComplex_extendMemoryPoolForFileIO ( );
4859 unsigned long SgTypeComplex_initializeStorageClassArray( SgTypeComplexStorageClass *storageArray );
4860 void SgTypeComplex_resetValidFreepointers( );
4861 unsigned long SgTypeComplex_getNumberOfLastValidPointer();
4862 
4863 
4864 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4865 
4866 #include <semaphore.h>
4867 // DQ (9/21/2005): Static variables supporting memory pools
4874 extern int SgTypeImaginary_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4875 
4880 extern SgTypeImaginary* SgTypeImaginary_Current_Link; // = NULL;
4881 
4882 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4883 // This is was one of the things on the todo list (above).
4884 
4889 extern std::vector < unsigned char* > SgTypeImaginary_Memory_Block_List;
4890 /* */
4891 
4892 // DQ (4/6/2006): Newer code from Jochen
4893 // Methods to find the pointer to a global and local index
4894 SgTypeImaginary* SgTypeImaginary_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4895 SgTypeImaginary* SgTypeImaginary_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4896 
4897 // Methods for computing the total size of the memory pool. It actually returns the
4898 // size of the whole blocks allocated, no matter they contain valid pointers or not
4899 unsigned long SgTypeImaginary_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4900 void SgTypeImaginary_clearMemoryPool ( );
4901 void SgTypeImaginary_extendMemoryPoolForFileIO ( );
4902 unsigned long SgTypeImaginary_initializeStorageClassArray( SgTypeImaginaryStorageClass *storageArray );
4903 void SgTypeImaginary_resetValidFreepointers( );
4904 unsigned long SgTypeImaginary_getNumberOfLastValidPointer();
4905 
4906 
4907 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4908 
4909 #include <semaphore.h>
4910 // DQ (9/21/2005): Static variables supporting memory pools
4917 extern int SgTypeDefault_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4918 
4923 extern SgTypeDefault* SgTypeDefault_Current_Link; // = NULL;
4924 
4925 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4926 // This is was one of the things on the todo list (above).
4927 
4932 extern std::vector < unsigned char* > SgTypeDefault_Memory_Block_List;
4933 /* */
4934 
4935 // DQ (4/6/2006): Newer code from Jochen
4936 // Methods to find the pointer to a global and local index
4937 SgTypeDefault* SgTypeDefault_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4938 SgTypeDefault* SgTypeDefault_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4939 
4940 // Methods for computing the total size of the memory pool. It actually returns the
4941 // size of the whole blocks allocated, no matter they contain valid pointers or not
4942 unsigned long SgTypeDefault_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4943 void SgTypeDefault_clearMemoryPool ( );
4944 void SgTypeDefault_extendMemoryPoolForFileIO ( );
4945 unsigned long SgTypeDefault_initializeStorageClassArray( SgTypeDefaultStorageClass *storageArray );
4946 void SgTypeDefault_resetValidFreepointers( );
4947 unsigned long SgTypeDefault_getNumberOfLastValidPointer();
4948 
4949 
4950 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4951 
4952 #include <semaphore.h>
4953 // DQ (9/21/2005): Static variables supporting memory pools
4960 extern int SgTypeCAFTeam_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
4961 
4966 extern SgTypeCAFTeam* SgTypeCAFTeam_Current_Link; // = NULL;
4967 
4968 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
4969 // This is was one of the things on the todo list (above).
4970 
4975 extern std::vector < unsigned char* > SgTypeCAFTeam_Memory_Block_List;
4976 /* */
4977 
4978 // DQ (4/6/2006): Newer code from Jochen
4979 // Methods to find the pointer to a global and local index
4980 SgTypeCAFTeam* SgTypeCAFTeam_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
4981 SgTypeCAFTeam* SgTypeCAFTeam_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
4982 
4983 // Methods for computing the total size of the memory pool. It actually returns the
4984 // size of the whole blocks allocated, no matter they contain valid pointers or not
4985 unsigned long SgTypeCAFTeam_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
4986 void SgTypeCAFTeam_clearMemoryPool ( );
4987 void SgTypeCAFTeam_extendMemoryPoolForFileIO ( );
4988 unsigned long SgTypeCAFTeam_initializeStorageClassArray( SgTypeCAFTeamStorageClass *storageArray );
4989 void SgTypeCAFTeam_resetValidFreepointers( );
4990 unsigned long SgTypeCAFTeam_getNumberOfLastValidPointer();
4991 
4992 
4993 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
4994 
4995 #include <semaphore.h>
4996 // DQ (9/21/2005): Static variables supporting memory pools
5003 extern int SgTypeCrayPointer_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5004 
5009 extern SgTypeCrayPointer* SgTypeCrayPointer_Current_Link; // = NULL;
5010 
5011 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5012 // This is was one of the things on the todo list (above).
5013 
5018 extern std::vector < unsigned char* > SgTypeCrayPointer_Memory_Block_List;
5019 /* */
5020 
5021 // DQ (4/6/2006): Newer code from Jochen
5022 // Methods to find the pointer to a global and local index
5023 SgTypeCrayPointer* SgTypeCrayPointer_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5024 SgTypeCrayPointer* SgTypeCrayPointer_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5025 
5026 // Methods for computing the total size of the memory pool. It actually returns the
5027 // size of the whole blocks allocated, no matter they contain valid pointers or not
5028 unsigned long SgTypeCrayPointer_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5029 void SgTypeCrayPointer_clearMemoryPool ( );
5030 void SgTypeCrayPointer_extendMemoryPoolForFileIO ( );
5031 unsigned long SgTypeCrayPointer_initializeStorageClassArray( SgTypeCrayPointerStorageClass *storageArray );
5032 void SgTypeCrayPointer_resetValidFreepointers( );
5033 unsigned long SgTypeCrayPointer_getNumberOfLastValidPointer();
5034 
5035 
5036 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5037 
5038 #include <semaphore.h>
5039 // DQ (9/21/2005): Static variables supporting memory pools
5046 extern int SgTypeLabel_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5047 
5052 extern SgTypeLabel* SgTypeLabel_Current_Link; // = NULL;
5053 
5054 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5055 // This is was one of the things on the todo list (above).
5056 
5061 extern std::vector < unsigned char* > SgTypeLabel_Memory_Block_List;
5062 /* */
5063 
5064 // DQ (4/6/2006): Newer code from Jochen
5065 // Methods to find the pointer to a global and local index
5066 SgTypeLabel* SgTypeLabel_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5067 SgTypeLabel* SgTypeLabel_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5068 
5069 // Methods for computing the total size of the memory pool. It actually returns the
5070 // size of the whole blocks allocated, no matter they contain valid pointers or not
5071 unsigned long SgTypeLabel_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5072 void SgTypeLabel_clearMemoryPool ( );
5073 void SgTypeLabel_extendMemoryPoolForFileIO ( );
5074 unsigned long SgTypeLabel_initializeStorageClassArray( SgTypeLabelStorageClass *storageArray );
5075 void SgTypeLabel_resetValidFreepointers( );
5076 unsigned long SgTypeLabel_getNumberOfLastValidPointer();
5077 
5078 
5079 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5080 
5081 #include <semaphore.h>
5082 // DQ (9/21/2005): Static variables supporting memory pools
5089 extern int SgJavaUnionType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5090 
5095 extern SgJavaUnionType* SgJavaUnionType_Current_Link; // = NULL;
5096 
5097 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5098 // This is was one of the things on the todo list (above).
5099 
5104 extern std::vector < unsigned char* > SgJavaUnionType_Memory_Block_List;
5105 /* */
5106 
5107 // DQ (4/6/2006): Newer code from Jochen
5108 // Methods to find the pointer to a global and local index
5109 SgJavaUnionType* SgJavaUnionType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5110 SgJavaUnionType* SgJavaUnionType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5111 
5112 // Methods for computing the total size of the memory pool. It actually returns the
5113 // size of the whole blocks allocated, no matter they contain valid pointers or not
5114 unsigned long SgJavaUnionType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5115 void SgJavaUnionType_clearMemoryPool ( );
5116 void SgJavaUnionType_extendMemoryPoolForFileIO ( );
5117 unsigned long SgJavaUnionType_initializeStorageClassArray( SgJavaUnionTypeStorageClass *storageArray );
5118 void SgJavaUnionType_resetValidFreepointers( );
5119 unsigned long SgJavaUnionType_getNumberOfLastValidPointer();
5120 
5121 
5122 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5123 
5124 #include <semaphore.h>
5125 // DQ (9/21/2005): Static variables supporting memory pools
5132 extern int SgRvalueReferenceType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5133 
5138 extern SgRvalueReferenceType* SgRvalueReferenceType_Current_Link; // = NULL;
5139 
5140 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5141 // This is was one of the things on the todo list (above).
5142 
5147 extern std::vector < unsigned char* > SgRvalueReferenceType_Memory_Block_List;
5148 /* */
5149 
5150 // DQ (4/6/2006): Newer code from Jochen
5151 // Methods to find the pointer to a global and local index
5152 SgRvalueReferenceType* SgRvalueReferenceType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5153 SgRvalueReferenceType* SgRvalueReferenceType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5154 
5155 // Methods for computing the total size of the memory pool. It actually returns the
5156 // size of the whole blocks allocated, no matter they contain valid pointers or not
5157 unsigned long SgRvalueReferenceType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5158 void SgRvalueReferenceType_clearMemoryPool ( );
5159 void SgRvalueReferenceType_extendMemoryPoolForFileIO ( );
5160 unsigned long SgRvalueReferenceType_initializeStorageClassArray( SgRvalueReferenceTypeStorageClass *storageArray );
5161 void SgRvalueReferenceType_resetValidFreepointers( );
5162 unsigned long SgRvalueReferenceType_getNumberOfLastValidPointer();
5163 
5164 
5165 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5166 
5167 #include <semaphore.h>
5168 // DQ (9/21/2005): Static variables supporting memory pools
5175 extern int SgTypeNullptr_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5176 
5181 extern SgTypeNullptr* SgTypeNullptr_Current_Link; // = NULL;
5182 
5183 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5184 // This is was one of the things on the todo list (above).
5185 
5190 extern std::vector < unsigned char* > SgTypeNullptr_Memory_Block_List;
5191 /* */
5192 
5193 // DQ (4/6/2006): Newer code from Jochen
5194 // Methods to find the pointer to a global and local index
5195 SgTypeNullptr* SgTypeNullptr_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5196 SgTypeNullptr* SgTypeNullptr_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5197 
5198 // Methods for computing the total size of the memory pool. It actually returns the
5199 // size of the whole blocks allocated, no matter they contain valid pointers or not
5200 unsigned long SgTypeNullptr_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5201 void SgTypeNullptr_clearMemoryPool ( );
5202 void SgTypeNullptr_extendMemoryPoolForFileIO ( );
5203 unsigned long SgTypeNullptr_initializeStorageClassArray( SgTypeNullptrStorageClass *storageArray );
5204 void SgTypeNullptr_resetValidFreepointers( );
5205 unsigned long SgTypeNullptr_getNumberOfLastValidPointer();
5206 
5207 
5208 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5209 
5210 #include <semaphore.h>
5211 // DQ (9/21/2005): Static variables supporting memory pools
5218 extern int SgDeclType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5219 
5224 extern SgDeclType* SgDeclType_Current_Link; // = NULL;
5225 
5226 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5227 // This is was one of the things on the todo list (above).
5228 
5233 extern std::vector < unsigned char* > SgDeclType_Memory_Block_List;
5234 /* */
5235 
5236 // DQ (4/6/2006): Newer code from Jochen
5237 // Methods to find the pointer to a global and local index
5238 SgDeclType* SgDeclType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5239 SgDeclType* SgDeclType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5240 
5241 // Methods for computing the total size of the memory pool. It actually returns the
5242 // size of the whole blocks allocated, no matter they contain valid pointers or not
5243 unsigned long SgDeclType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5244 void SgDeclType_clearMemoryPool ( );
5245 void SgDeclType_extendMemoryPoolForFileIO ( );
5246 unsigned long SgDeclType_initializeStorageClassArray( SgDeclTypeStorageClass *storageArray );
5247 void SgDeclType_resetValidFreepointers( );
5248 unsigned long SgDeclType_getNumberOfLastValidPointer();
5249 
5250 
5251 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5252 
5253 #include <semaphore.h>
5254 // DQ (9/21/2005): Static variables supporting memory pools
5261 extern int SgTypeOfType_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5262 
5267 extern SgTypeOfType* SgTypeOfType_Current_Link; // = NULL;
5268 
5269 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5270 // This is was one of the things on the todo list (above).
5271 
5276 extern std::vector < unsigned char* > SgTypeOfType_Memory_Block_List;
5277 /* */
5278 
5279 // DQ (4/6/2006): Newer code from Jochen
5280 // Methods to find the pointer to a global and local index
5281 SgTypeOfType* SgTypeOfType_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5282 SgTypeOfType* SgTypeOfType_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5283 
5284 // Methods for computing the total size of the memory pool. It actually returns the
5285 // size of the whole blocks allocated, no matter they contain valid pointers or not
5286 unsigned long SgTypeOfType_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5287 void SgTypeOfType_clearMemoryPool ( );
5288 void SgTypeOfType_extendMemoryPoolForFileIO ( );
5289 unsigned long SgTypeOfType_initializeStorageClassArray( SgTypeOfTypeStorageClass *storageArray );
5290 void SgTypeOfType_resetValidFreepointers( );
5291 unsigned long SgTypeOfType_getNumberOfLastValidPointer();
5292 
5293 
5294 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5295 
5296 #include <semaphore.h>
5297 // DQ (9/21/2005): Static variables supporting memory pools
5304 extern int SgTypeMatrix_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5305 
5310 extern SgTypeMatrix* SgTypeMatrix_Current_Link; // = NULL;
5311 
5312 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5313 // This is was one of the things on the todo list (above).
5314 
5319 extern std::vector < unsigned char* > SgTypeMatrix_Memory_Block_List;
5320 /* */
5321 
5322 // DQ (4/6/2006): Newer code from Jochen
5323 // Methods to find the pointer to a global and local index
5324 SgTypeMatrix* SgTypeMatrix_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5325 SgTypeMatrix* SgTypeMatrix_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5326 
5327 // Methods for computing the total size of the memory pool. It actually returns the
5328 // size of the whole blocks allocated, no matter they contain valid pointers or not
5329 unsigned long SgTypeMatrix_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5330 void SgTypeMatrix_clearMemoryPool ( );
5331 void SgTypeMatrix_extendMemoryPoolForFileIO ( );
5332 unsigned long SgTypeMatrix_initializeStorageClassArray( SgTypeMatrixStorageClass *storageArray );
5333 void SgTypeMatrix_resetValidFreepointers( );
5334 unsigned long SgTypeMatrix_getNumberOfLastValidPointer();
5335 
5336 
5337 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5338 
5339 #include <semaphore.h>
5340 // DQ (9/21/2005): Static variables supporting memory pools
5347 extern int SgTypeTuple_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5348 
5353 extern SgTypeTuple* SgTypeTuple_Current_Link; // = NULL;
5354 
5355 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5356 // This is was one of the things on the todo list (above).
5357 
5362 extern std::vector < unsigned char* > SgTypeTuple_Memory_Block_List;
5363 /* */
5364 
5365 // DQ (4/6/2006): Newer code from Jochen
5366 // Methods to find the pointer to a global and local index
5367 SgTypeTuple* SgTypeTuple_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5368 SgTypeTuple* SgTypeTuple_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5369 
5370 // Methods for computing the total size of the memory pool. It actually returns the
5371 // size of the whole blocks allocated, no matter they contain valid pointers or not
5372 unsigned long SgTypeTuple_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5373 void SgTypeTuple_clearMemoryPool ( );
5374 void SgTypeTuple_extendMemoryPoolForFileIO ( );
5375 unsigned long SgTypeTuple_initializeStorageClassArray( SgTypeTupleStorageClass *storageArray );
5376 void SgTypeTuple_resetValidFreepointers( );
5377 unsigned long SgTypeTuple_getNumberOfLastValidPointer();
5378 
5379 
5380 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5381 
5382 #include <semaphore.h>
5383 // DQ (9/21/2005): Static variables supporting memory pools
5390 extern int SgLocatedNode_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5391 
5396 extern SgLocatedNode* SgLocatedNode_Current_Link; // = NULL;
5397 
5398 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5399 // This is was one of the things on the todo list (above).
5400 
5405 extern std::vector < unsigned char* > SgLocatedNode_Memory_Block_List;
5406 /* */
5407 
5408 // DQ (4/6/2006): Newer code from Jochen
5409 // Methods to find the pointer to a global and local index
5410 SgLocatedNode* SgLocatedNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5411 SgLocatedNode* SgLocatedNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5412 
5413 // Methods for computing the total size of the memory pool. It actually returns the
5414 // size of the whole blocks allocated, no matter they contain valid pointers or not
5415 unsigned long SgLocatedNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5416 void SgLocatedNode_clearMemoryPool ( );
5417 void SgLocatedNode_extendMemoryPoolForFileIO ( );
5418 unsigned long SgLocatedNode_initializeStorageClassArray( SgLocatedNodeStorageClass *storageArray );
5419 void SgLocatedNode_resetValidFreepointers( );
5420 unsigned long SgLocatedNode_getNumberOfLastValidPointer();
5421 
5422 
5423 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5424 
5425 #include <semaphore.h>
5426 // DQ (9/21/2005): Static variables supporting memory pools
5433 extern int SgToken_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5434 
5439 extern SgToken* SgToken_Current_Link; // = NULL;
5440 
5441 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5442 // This is was one of the things on the todo list (above).
5443 
5448 extern std::vector < unsigned char* > SgToken_Memory_Block_List;
5449 /* */
5450 
5451 // DQ (4/6/2006): Newer code from Jochen
5452 // Methods to find the pointer to a global and local index
5453 SgToken* SgToken_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5454 SgToken* SgToken_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5455 
5456 // Methods for computing the total size of the memory pool. It actually returns the
5457 // size of the whole blocks allocated, no matter they contain valid pointers or not
5458 unsigned long SgToken_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5459 void SgToken_clearMemoryPool ( );
5460 void SgToken_extendMemoryPoolForFileIO ( );
5461 unsigned long SgToken_initializeStorageClassArray( SgTokenStorageClass *storageArray );
5462 void SgToken_resetValidFreepointers( );
5463 unsigned long SgToken_getNumberOfLastValidPointer();
5464 
5465 
5466 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5467 
5468 #include <semaphore.h>
5469 // DQ (9/21/2005): Static variables supporting memory pools
5476 extern int SgLocatedNodeSupport_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5477 
5482 extern SgLocatedNodeSupport* SgLocatedNodeSupport_Current_Link; // = NULL;
5483 
5484 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5485 // This is was one of the things on the todo list (above).
5486 
5491 extern std::vector < unsigned char* > SgLocatedNodeSupport_Memory_Block_List;
5492 /* */
5493 
5494 // DQ (4/6/2006): Newer code from Jochen
5495 // Methods to find the pointer to a global and local index
5496 SgLocatedNodeSupport* SgLocatedNodeSupport_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5497 SgLocatedNodeSupport* SgLocatedNodeSupport_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5498 
5499 // Methods for computing the total size of the memory pool. It actually returns the
5500 // size of the whole blocks allocated, no matter they contain valid pointers or not
5501 unsigned long SgLocatedNodeSupport_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5502 void SgLocatedNodeSupport_clearMemoryPool ( );
5503 void SgLocatedNodeSupport_extendMemoryPoolForFileIO ( );
5504 unsigned long SgLocatedNodeSupport_initializeStorageClassArray( SgLocatedNodeSupportStorageClass *storageArray );
5505 void SgLocatedNodeSupport_resetValidFreepointers( );
5506 unsigned long SgLocatedNodeSupport_getNumberOfLastValidPointer();
5507 
5508 
5509 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5510 
5511 #include <semaphore.h>
5512 // DQ (9/21/2005): Static variables supporting memory pools
5519 extern int SgCommonBlockObject_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5520 
5525 extern SgCommonBlockObject* SgCommonBlockObject_Current_Link; // = NULL;
5526 
5527 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5528 // This is was one of the things on the todo list (above).
5529 
5534 extern std::vector < unsigned char* > SgCommonBlockObject_Memory_Block_List;
5535 /* */
5536 
5537 // DQ (4/6/2006): Newer code from Jochen
5538 // Methods to find the pointer to a global and local index
5539 SgCommonBlockObject* SgCommonBlockObject_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5540 SgCommonBlockObject* SgCommonBlockObject_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5541 
5542 // Methods for computing the total size of the memory pool. It actually returns the
5543 // size of the whole blocks allocated, no matter they contain valid pointers or not
5544 unsigned long SgCommonBlockObject_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5545 void SgCommonBlockObject_clearMemoryPool ( );
5546 void SgCommonBlockObject_extendMemoryPoolForFileIO ( );
5547 unsigned long SgCommonBlockObject_initializeStorageClassArray( SgCommonBlockObjectStorageClass *storageArray );
5548 void SgCommonBlockObject_resetValidFreepointers( );
5549 unsigned long SgCommonBlockObject_getNumberOfLastValidPointer();
5550 
5551 
5552 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5553 
5554 #include <semaphore.h>
5555 // DQ (9/21/2005): Static variables supporting memory pools
5562 extern int SgInitializedName_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5563 
5568 extern SgInitializedName* SgInitializedName_Current_Link; // = NULL;
5569 
5570 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5571 // This is was one of the things on the todo list (above).
5572 
5577 extern std::vector < unsigned char* > SgInitializedName_Memory_Block_List;
5578 /* */
5579 
5580 // DQ (4/6/2006): Newer code from Jochen
5581 // Methods to find the pointer to a global and local index
5582 SgInitializedName* SgInitializedName_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5583 SgInitializedName* SgInitializedName_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5584 
5585 // Methods for computing the total size of the memory pool. It actually returns the
5586 // size of the whole blocks allocated, no matter they contain valid pointers or not
5587 unsigned long SgInitializedName_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5588 void SgInitializedName_clearMemoryPool ( );
5589 void SgInitializedName_extendMemoryPoolForFileIO ( );
5590 unsigned long SgInitializedName_initializeStorageClassArray( SgInitializedNameStorageClass *storageArray );
5591 void SgInitializedName_resetValidFreepointers( );
5592 unsigned long SgInitializedName_getNumberOfLastValidPointer();
5593 
5594 
5595 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5596 
5597 #include <semaphore.h>
5598 // DQ (9/21/2005): Static variables supporting memory pools
5605 extern int SgInterfaceBody_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5606 
5611 extern SgInterfaceBody* SgInterfaceBody_Current_Link; // = NULL;
5612 
5613 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5614 // This is was one of the things on the todo list (above).
5615 
5620 extern std::vector < unsigned char* > SgInterfaceBody_Memory_Block_List;
5621 /* */
5622 
5623 // DQ (4/6/2006): Newer code from Jochen
5624 // Methods to find the pointer to a global and local index
5625 SgInterfaceBody* SgInterfaceBody_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5626 SgInterfaceBody* SgInterfaceBody_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5627 
5628 // Methods for computing the total size of the memory pool. It actually returns the
5629 // size of the whole blocks allocated, no matter they contain valid pointers or not
5630 unsigned long SgInterfaceBody_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5631 void SgInterfaceBody_clearMemoryPool ( );
5632 void SgInterfaceBody_extendMemoryPoolForFileIO ( );
5633 unsigned long SgInterfaceBody_initializeStorageClassArray( SgInterfaceBodyStorageClass *storageArray );
5634 void SgInterfaceBody_resetValidFreepointers( );
5635 unsigned long SgInterfaceBody_getNumberOfLastValidPointer();
5636 
5637 
5638 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5639 
5640 #include <semaphore.h>
5641 // DQ (9/21/2005): Static variables supporting memory pools
5648 extern int SgHeaderFileBody_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5649 
5654 extern SgHeaderFileBody* SgHeaderFileBody_Current_Link; // = NULL;
5655 
5656 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5657 // This is was one of the things on the todo list (above).
5658 
5663 extern std::vector < unsigned char* > SgHeaderFileBody_Memory_Block_List;
5664 /* */
5665 
5666 // DQ (4/6/2006): Newer code from Jochen
5667 // Methods to find the pointer to a global and local index
5668 SgHeaderFileBody* SgHeaderFileBody_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5669 SgHeaderFileBody* SgHeaderFileBody_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5670 
5671 // Methods for computing the total size of the memory pool. It actually returns the
5672 // size of the whole blocks allocated, no matter they contain valid pointers or not
5673 unsigned long SgHeaderFileBody_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5674 void SgHeaderFileBody_clearMemoryPool ( );
5675 void SgHeaderFileBody_extendMemoryPoolForFileIO ( );
5676 unsigned long SgHeaderFileBody_initializeStorageClassArray( SgHeaderFileBodyStorageClass *storageArray );
5677 void SgHeaderFileBody_resetValidFreepointers( );
5678 unsigned long SgHeaderFileBody_getNumberOfLastValidPointer();
5679 
5680 
5681 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5682 
5683 #include <semaphore.h>
5684 // DQ (9/21/2005): Static variables supporting memory pools
5691 extern int SgRenamePair_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5692 
5697 extern SgRenamePair* SgRenamePair_Current_Link; // = NULL;
5698 
5699 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5700 // This is was one of the things on the todo list (above).
5701 
5706 extern std::vector < unsigned char* > SgRenamePair_Memory_Block_List;
5707 /* */
5708 
5709 // DQ (4/6/2006): Newer code from Jochen
5710 // Methods to find the pointer to a global and local index
5711 SgRenamePair* SgRenamePair_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5712 SgRenamePair* SgRenamePair_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5713 
5714 // Methods for computing the total size of the memory pool. It actually returns the
5715 // size of the whole blocks allocated, no matter they contain valid pointers or not
5716 unsigned long SgRenamePair_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5717 void SgRenamePair_clearMemoryPool ( );
5718 void SgRenamePair_extendMemoryPoolForFileIO ( );
5719 unsigned long SgRenamePair_initializeStorageClassArray( SgRenamePairStorageClass *storageArray );
5720 void SgRenamePair_resetValidFreepointers( );
5721 unsigned long SgRenamePair_getNumberOfLastValidPointer();
5722 
5723 
5724 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5725 
5726 #include <semaphore.h>
5727 // DQ (9/21/2005): Static variables supporting memory pools
5734 extern int SgJavaMemberValuePair_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5735 
5740 extern SgJavaMemberValuePair* SgJavaMemberValuePair_Current_Link; // = NULL;
5741 
5742 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5743 // This is was one of the things on the todo list (above).
5744 
5749 extern std::vector < unsigned char* > SgJavaMemberValuePair_Memory_Block_List;
5750 /* */
5751 
5752 // DQ (4/6/2006): Newer code from Jochen
5753 // Methods to find the pointer to a global and local index
5754 SgJavaMemberValuePair* SgJavaMemberValuePair_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5755 SgJavaMemberValuePair* SgJavaMemberValuePair_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5756 
5757 // Methods for computing the total size of the memory pool. It actually returns the
5758 // size of the whole blocks allocated, no matter they contain valid pointers or not
5759 unsigned long SgJavaMemberValuePair_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5760 void SgJavaMemberValuePair_clearMemoryPool ( );
5761 void SgJavaMemberValuePair_extendMemoryPoolForFileIO ( );
5762 unsigned long SgJavaMemberValuePair_initializeStorageClassArray( SgJavaMemberValuePairStorageClass *storageArray );
5763 void SgJavaMemberValuePair_resetValidFreepointers( );
5764 unsigned long SgJavaMemberValuePair_getNumberOfLastValidPointer();
5765 
5766 
5767 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5768 
5769 #include <semaphore.h>
5770 // DQ (9/21/2005): Static variables supporting memory pools
5777 extern int SgOmpClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5778 
5783 extern SgOmpClause* SgOmpClause_Current_Link; // = NULL;
5784 
5785 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5786 // This is was one of the things on the todo list (above).
5787 
5792 extern std::vector < unsigned char* > SgOmpClause_Memory_Block_List;
5793 /* */
5794 
5795 // DQ (4/6/2006): Newer code from Jochen
5796 // Methods to find the pointer to a global and local index
5797 SgOmpClause* SgOmpClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5798 SgOmpClause* SgOmpClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5799 
5800 // Methods for computing the total size of the memory pool. It actually returns the
5801 // size of the whole blocks allocated, no matter they contain valid pointers or not
5802 unsigned long SgOmpClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5803 void SgOmpClause_clearMemoryPool ( );
5804 void SgOmpClause_extendMemoryPoolForFileIO ( );
5805 unsigned long SgOmpClause_initializeStorageClassArray( SgOmpClauseStorageClass *storageArray );
5806 void SgOmpClause_resetValidFreepointers( );
5807 unsigned long SgOmpClause_getNumberOfLastValidPointer();
5808 
5809 
5810 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5811 
5812 #include <semaphore.h>
5813 // DQ (9/21/2005): Static variables supporting memory pools
5820 extern int SgOmpOrderedClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5821 
5826 extern SgOmpOrderedClause* SgOmpOrderedClause_Current_Link; // = NULL;
5827 
5828 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5829 // This is was one of the things on the todo list (above).
5830 
5835 extern std::vector < unsigned char* > SgOmpOrderedClause_Memory_Block_List;
5836 /* */
5837 
5838 // DQ (4/6/2006): Newer code from Jochen
5839 // Methods to find the pointer to a global and local index
5840 SgOmpOrderedClause* SgOmpOrderedClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5841 SgOmpOrderedClause* SgOmpOrderedClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5842 
5843 // Methods for computing the total size of the memory pool. It actually returns the
5844 // size of the whole blocks allocated, no matter they contain valid pointers or not
5845 unsigned long SgOmpOrderedClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5846 void SgOmpOrderedClause_clearMemoryPool ( );
5847 void SgOmpOrderedClause_extendMemoryPoolForFileIO ( );
5848 unsigned long SgOmpOrderedClause_initializeStorageClassArray( SgOmpOrderedClauseStorageClass *storageArray );
5849 void SgOmpOrderedClause_resetValidFreepointers( );
5850 unsigned long SgOmpOrderedClause_getNumberOfLastValidPointer();
5851 
5852 
5853 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5854 
5855 #include <semaphore.h>
5856 // DQ (9/21/2005): Static variables supporting memory pools
5863 extern int SgOmpNowaitClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5864 
5869 extern SgOmpNowaitClause* SgOmpNowaitClause_Current_Link; // = NULL;
5870 
5871 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5872 // This is was one of the things on the todo list (above).
5873 
5878 extern std::vector < unsigned char* > SgOmpNowaitClause_Memory_Block_List;
5879 /* */
5880 
5881 // DQ (4/6/2006): Newer code from Jochen
5882 // Methods to find the pointer to a global and local index
5883 SgOmpNowaitClause* SgOmpNowaitClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5884 SgOmpNowaitClause* SgOmpNowaitClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5885 
5886 // Methods for computing the total size of the memory pool. It actually returns the
5887 // size of the whole blocks allocated, no matter they contain valid pointers or not
5888 unsigned long SgOmpNowaitClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5889 void SgOmpNowaitClause_clearMemoryPool ( );
5890 void SgOmpNowaitClause_extendMemoryPoolForFileIO ( );
5891 unsigned long SgOmpNowaitClause_initializeStorageClassArray( SgOmpNowaitClauseStorageClass *storageArray );
5892 void SgOmpNowaitClause_resetValidFreepointers( );
5893 unsigned long SgOmpNowaitClause_getNumberOfLastValidPointer();
5894 
5895 
5896 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5897 
5898 #include <semaphore.h>
5899 // DQ (9/21/2005): Static variables supporting memory pools
5906 extern int SgOmpBeginClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5907 
5912 extern SgOmpBeginClause* SgOmpBeginClause_Current_Link; // = NULL;
5913 
5914 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5915 // This is was one of the things on the todo list (above).
5916 
5921 extern std::vector < unsigned char* > SgOmpBeginClause_Memory_Block_List;
5922 /* */
5923 
5924 // DQ (4/6/2006): Newer code from Jochen
5925 // Methods to find the pointer to a global and local index
5926 SgOmpBeginClause* SgOmpBeginClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5927 SgOmpBeginClause* SgOmpBeginClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5928 
5929 // Methods for computing the total size of the memory pool. It actually returns the
5930 // size of the whole blocks allocated, no matter they contain valid pointers or not
5931 unsigned long SgOmpBeginClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5932 void SgOmpBeginClause_clearMemoryPool ( );
5933 void SgOmpBeginClause_extendMemoryPoolForFileIO ( );
5934 unsigned long SgOmpBeginClause_initializeStorageClassArray( SgOmpBeginClauseStorageClass *storageArray );
5935 void SgOmpBeginClause_resetValidFreepointers( );
5936 unsigned long SgOmpBeginClause_getNumberOfLastValidPointer();
5937 
5938 
5939 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5940 
5941 #include <semaphore.h>
5942 // DQ (9/21/2005): Static variables supporting memory pools
5949 extern int SgOmpEndClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5950 
5955 extern SgOmpEndClause* SgOmpEndClause_Current_Link; // = NULL;
5956 
5957 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
5958 // This is was one of the things on the todo list (above).
5959 
5964 extern std::vector < unsigned char* > SgOmpEndClause_Memory_Block_List;
5965 /* */
5966 
5967 // DQ (4/6/2006): Newer code from Jochen
5968 // Methods to find the pointer to a global and local index
5969 SgOmpEndClause* SgOmpEndClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
5970 SgOmpEndClause* SgOmpEndClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
5971 
5972 // Methods for computing the total size of the memory pool. It actually returns the
5973 // size of the whole blocks allocated, no matter they contain valid pointers or not
5974 unsigned long SgOmpEndClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
5975 void SgOmpEndClause_clearMemoryPool ( );
5976 void SgOmpEndClause_extendMemoryPoolForFileIO ( );
5977 unsigned long SgOmpEndClause_initializeStorageClassArray( SgOmpEndClauseStorageClass *storageArray );
5978 void SgOmpEndClause_resetValidFreepointers( );
5979 unsigned long SgOmpEndClause_getNumberOfLastValidPointer();
5980 
5981 
5982 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
5983 
5984 #include <semaphore.h>
5985 // DQ (9/21/2005): Static variables supporting memory pools
5992 extern int SgOmpUntiedClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
5993 
5998 extern SgOmpUntiedClause* SgOmpUntiedClause_Current_Link; // = NULL;
5999 
6000 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6001 // This is was one of the things on the todo list (above).
6002 
6007 extern std::vector < unsigned char* > SgOmpUntiedClause_Memory_Block_List;
6008 /* */
6009 
6010 // DQ (4/6/2006): Newer code from Jochen
6011 // Methods to find the pointer to a global and local index
6012 SgOmpUntiedClause* SgOmpUntiedClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6013 SgOmpUntiedClause* SgOmpUntiedClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6014 
6015 // Methods for computing the total size of the memory pool. It actually returns the
6016 // size of the whole blocks allocated, no matter they contain valid pointers or not
6017 unsigned long SgOmpUntiedClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6018 void SgOmpUntiedClause_clearMemoryPool ( );
6019 void SgOmpUntiedClause_extendMemoryPoolForFileIO ( );
6020 unsigned long SgOmpUntiedClause_initializeStorageClassArray( SgOmpUntiedClauseStorageClass *storageArray );
6021 void SgOmpUntiedClause_resetValidFreepointers( );
6022 unsigned long SgOmpUntiedClause_getNumberOfLastValidPointer();
6023 
6024 
6025 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6026 
6027 #include <semaphore.h>
6028 // DQ (9/21/2005): Static variables supporting memory pools
6035 extern int SgOmpDefaultClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6036 
6041 extern SgOmpDefaultClause* SgOmpDefaultClause_Current_Link; // = NULL;
6042 
6043 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6044 // This is was one of the things on the todo list (above).
6045 
6050 extern std::vector < unsigned char* > SgOmpDefaultClause_Memory_Block_List;
6051 /* */
6052 
6053 // DQ (4/6/2006): Newer code from Jochen
6054 // Methods to find the pointer to a global and local index
6055 SgOmpDefaultClause* SgOmpDefaultClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6056 SgOmpDefaultClause* SgOmpDefaultClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6057 
6058 // Methods for computing the total size of the memory pool. It actually returns the
6059 // size of the whole blocks allocated, no matter they contain valid pointers or not
6060 unsigned long SgOmpDefaultClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6061 void SgOmpDefaultClause_clearMemoryPool ( );
6062 void SgOmpDefaultClause_extendMemoryPoolForFileIO ( );
6063 unsigned long SgOmpDefaultClause_initializeStorageClassArray( SgOmpDefaultClauseStorageClass *storageArray );
6064 void SgOmpDefaultClause_resetValidFreepointers( );
6065 unsigned long SgOmpDefaultClause_getNumberOfLastValidPointer();
6066 
6067 
6068 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6069 
6070 #include <semaphore.h>
6071 // DQ (9/21/2005): Static variables supporting memory pools
6078 extern int SgOmpAtomicClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6079 
6084 extern SgOmpAtomicClause* SgOmpAtomicClause_Current_Link; // = NULL;
6085 
6086 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6087 // This is was one of the things on the todo list (above).
6088 
6093 extern std::vector < unsigned char* > SgOmpAtomicClause_Memory_Block_List;
6094 /* */
6095 
6096 // DQ (4/6/2006): Newer code from Jochen
6097 // Methods to find the pointer to a global and local index
6098 SgOmpAtomicClause* SgOmpAtomicClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6099 SgOmpAtomicClause* SgOmpAtomicClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6100 
6101 // Methods for computing the total size of the memory pool. It actually returns the
6102 // size of the whole blocks allocated, no matter they contain valid pointers or not
6103 unsigned long SgOmpAtomicClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6104 void SgOmpAtomicClause_clearMemoryPool ( );
6105 void SgOmpAtomicClause_extendMemoryPoolForFileIO ( );
6106 unsigned long SgOmpAtomicClause_initializeStorageClassArray( SgOmpAtomicClauseStorageClass *storageArray );
6107 void SgOmpAtomicClause_resetValidFreepointers( );
6108 unsigned long SgOmpAtomicClause_getNumberOfLastValidPointer();
6109 
6110 
6111 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6112 
6113 #include <semaphore.h>
6114 // DQ (9/21/2005): Static variables supporting memory pools
6121 extern int SgOmpProcBindClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6122 
6127 extern SgOmpProcBindClause* SgOmpProcBindClause_Current_Link; // = NULL;
6128 
6129 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6130 // This is was one of the things on the todo list (above).
6131 
6136 extern std::vector < unsigned char* > SgOmpProcBindClause_Memory_Block_List;
6137 /* */
6138 
6139 // DQ (4/6/2006): Newer code from Jochen
6140 // Methods to find the pointer to a global and local index
6141 SgOmpProcBindClause* SgOmpProcBindClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6142 SgOmpProcBindClause* SgOmpProcBindClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6143 
6144 // Methods for computing the total size of the memory pool. It actually returns the
6145 // size of the whole blocks allocated, no matter they contain valid pointers or not
6146 unsigned long SgOmpProcBindClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6147 void SgOmpProcBindClause_clearMemoryPool ( );
6148 void SgOmpProcBindClause_extendMemoryPoolForFileIO ( );
6149 unsigned long SgOmpProcBindClause_initializeStorageClassArray( SgOmpProcBindClauseStorageClass *storageArray );
6150 void SgOmpProcBindClause_resetValidFreepointers( );
6151 unsigned long SgOmpProcBindClause_getNumberOfLastValidPointer();
6152 
6153 
6154 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6155 
6156 #include <semaphore.h>
6157 // DQ (9/21/2005): Static variables supporting memory pools
6164 extern int SgOmpExpressionClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6165 
6170 extern SgOmpExpressionClause* SgOmpExpressionClause_Current_Link; // = NULL;
6171 
6172 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6173 // This is was one of the things on the todo list (above).
6174 
6179 extern std::vector < unsigned char* > SgOmpExpressionClause_Memory_Block_List;
6180 /* */
6181 
6182 // DQ (4/6/2006): Newer code from Jochen
6183 // Methods to find the pointer to a global and local index
6184 SgOmpExpressionClause* SgOmpExpressionClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6185 SgOmpExpressionClause* SgOmpExpressionClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6186 
6187 // Methods for computing the total size of the memory pool. It actually returns the
6188 // size of the whole blocks allocated, no matter they contain valid pointers or not
6189 unsigned long SgOmpExpressionClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6190 void SgOmpExpressionClause_clearMemoryPool ( );
6191 void SgOmpExpressionClause_extendMemoryPoolForFileIO ( );
6192 unsigned long SgOmpExpressionClause_initializeStorageClassArray( SgOmpExpressionClauseStorageClass *storageArray );
6193 void SgOmpExpressionClause_resetValidFreepointers( );
6194 unsigned long SgOmpExpressionClause_getNumberOfLastValidPointer();
6195 
6196 
6197 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6198 
6199 #include <semaphore.h>
6200 // DQ (9/21/2005): Static variables supporting memory pools
6207 extern int SgOmpCollapseClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6208 
6213 extern SgOmpCollapseClause* SgOmpCollapseClause_Current_Link; // = NULL;
6214 
6215 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6216 // This is was one of the things on the todo list (above).
6217 
6222 extern std::vector < unsigned char* > SgOmpCollapseClause_Memory_Block_List;
6223 /* */
6224 
6225 // DQ (4/6/2006): Newer code from Jochen
6226 // Methods to find the pointer to a global and local index
6227 SgOmpCollapseClause* SgOmpCollapseClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6228 SgOmpCollapseClause* SgOmpCollapseClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6229 
6230 // Methods for computing the total size of the memory pool. It actually returns the
6231 // size of the whole blocks allocated, no matter they contain valid pointers or not
6232 unsigned long SgOmpCollapseClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6233 void SgOmpCollapseClause_clearMemoryPool ( );
6234 void SgOmpCollapseClause_extendMemoryPoolForFileIO ( );
6235 unsigned long SgOmpCollapseClause_initializeStorageClassArray( SgOmpCollapseClauseStorageClass *storageArray );
6236 void SgOmpCollapseClause_resetValidFreepointers( );
6237 unsigned long SgOmpCollapseClause_getNumberOfLastValidPointer();
6238 
6239 
6240 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6241 
6242 #include <semaphore.h>
6243 // DQ (9/21/2005): Static variables supporting memory pools
6250 extern int SgOmpIfClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6251 
6256 extern SgOmpIfClause* SgOmpIfClause_Current_Link; // = NULL;
6257 
6258 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6259 // This is was one of the things on the todo list (above).
6260 
6265 extern std::vector < unsigned char* > SgOmpIfClause_Memory_Block_List;
6266 /* */
6267 
6268 // DQ (4/6/2006): Newer code from Jochen
6269 // Methods to find the pointer to a global and local index
6270 SgOmpIfClause* SgOmpIfClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6271 SgOmpIfClause* SgOmpIfClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6272 
6273 // Methods for computing the total size of the memory pool. It actually returns the
6274 // size of the whole blocks allocated, no matter they contain valid pointers or not
6275 unsigned long SgOmpIfClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6276 void SgOmpIfClause_clearMemoryPool ( );
6277 void SgOmpIfClause_extendMemoryPoolForFileIO ( );
6278 unsigned long SgOmpIfClause_initializeStorageClassArray( SgOmpIfClauseStorageClass *storageArray );
6279 void SgOmpIfClause_resetValidFreepointers( );
6280 unsigned long SgOmpIfClause_getNumberOfLastValidPointer();
6281 
6282 
6283 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6284 
6285 #include <semaphore.h>
6286 // DQ (9/21/2005): Static variables supporting memory pools
6293 extern int SgOmpNumThreadsClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6294 
6299 extern SgOmpNumThreadsClause* SgOmpNumThreadsClause_Current_Link; // = NULL;
6300 
6301 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6302 // This is was one of the things on the todo list (above).
6303 
6308 extern std::vector < unsigned char* > SgOmpNumThreadsClause_Memory_Block_List;
6309 /* */
6310 
6311 // DQ (4/6/2006): Newer code from Jochen
6312 // Methods to find the pointer to a global and local index
6313 SgOmpNumThreadsClause* SgOmpNumThreadsClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6314 SgOmpNumThreadsClause* SgOmpNumThreadsClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6315 
6316 // Methods for computing the total size of the memory pool. It actually returns the
6317 // size of the whole blocks allocated, no matter they contain valid pointers or not
6318 unsigned long SgOmpNumThreadsClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6319 void SgOmpNumThreadsClause_clearMemoryPool ( );
6320 void SgOmpNumThreadsClause_extendMemoryPoolForFileIO ( );
6321 unsigned long SgOmpNumThreadsClause_initializeStorageClassArray( SgOmpNumThreadsClauseStorageClass *storageArray );
6322 void SgOmpNumThreadsClause_resetValidFreepointers( );
6323 unsigned long SgOmpNumThreadsClause_getNumberOfLastValidPointer();
6324 
6325 
6326 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6327 
6328 #include <semaphore.h>
6329 // DQ (9/21/2005): Static variables supporting memory pools
6336 extern int SgOmpDeviceClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6337 
6342 extern SgOmpDeviceClause* SgOmpDeviceClause_Current_Link; // = NULL;
6343 
6344 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6345 // This is was one of the things on the todo list (above).
6346 
6351 extern std::vector < unsigned char* > SgOmpDeviceClause_Memory_Block_List;
6352 /* */
6353 
6354 // DQ (4/6/2006): Newer code from Jochen
6355 // Methods to find the pointer to a global and local index
6356 SgOmpDeviceClause* SgOmpDeviceClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6357 SgOmpDeviceClause* SgOmpDeviceClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6358 
6359 // Methods for computing the total size of the memory pool. It actually returns the
6360 // size of the whole blocks allocated, no matter they contain valid pointers or not
6361 unsigned long SgOmpDeviceClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6362 void SgOmpDeviceClause_clearMemoryPool ( );
6363 void SgOmpDeviceClause_extendMemoryPoolForFileIO ( );
6364 unsigned long SgOmpDeviceClause_initializeStorageClassArray( SgOmpDeviceClauseStorageClass *storageArray );
6365 void SgOmpDeviceClause_resetValidFreepointers( );
6366 unsigned long SgOmpDeviceClause_getNumberOfLastValidPointer();
6367 
6368 
6369 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6370 
6371 #include <semaphore.h>
6372 // DQ (9/21/2005): Static variables supporting memory pools
6379 extern int SgOmpSafelenClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6380 
6385 extern SgOmpSafelenClause* SgOmpSafelenClause_Current_Link; // = NULL;
6386 
6387 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6388 // This is was one of the things on the todo list (above).
6389 
6394 extern std::vector < unsigned char* > SgOmpSafelenClause_Memory_Block_List;
6395 /* */
6396 
6397 // DQ (4/6/2006): Newer code from Jochen
6398 // Methods to find the pointer to a global and local index
6399 SgOmpSafelenClause* SgOmpSafelenClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6400 SgOmpSafelenClause* SgOmpSafelenClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6401 
6402 // Methods for computing the total size of the memory pool. It actually returns the
6403 // size of the whole blocks allocated, no matter they contain valid pointers or not
6404 unsigned long SgOmpSafelenClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6405 void SgOmpSafelenClause_clearMemoryPool ( );
6406 void SgOmpSafelenClause_extendMemoryPoolForFileIO ( );
6407 unsigned long SgOmpSafelenClause_initializeStorageClassArray( SgOmpSafelenClauseStorageClass *storageArray );
6408 void SgOmpSafelenClause_resetValidFreepointers( );
6409 unsigned long SgOmpSafelenClause_getNumberOfLastValidPointer();
6410 
6411 
6412 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6413 
6414 #include <semaphore.h>
6415 // DQ (9/21/2005): Static variables supporting memory pools
6422 extern int SgOmpSimdlenClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6423 
6428 extern SgOmpSimdlenClause* SgOmpSimdlenClause_Current_Link; // = NULL;
6429 
6430 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6431 // This is was one of the things on the todo list (above).
6432 
6437 extern std::vector < unsigned char* > SgOmpSimdlenClause_Memory_Block_List;
6438 /* */
6439 
6440 // DQ (4/6/2006): Newer code from Jochen
6441 // Methods to find the pointer to a global and local index
6442 SgOmpSimdlenClause* SgOmpSimdlenClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6443 SgOmpSimdlenClause* SgOmpSimdlenClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6444 
6445 // Methods for computing the total size of the memory pool. It actually returns the
6446 // size of the whole blocks allocated, no matter they contain valid pointers or not
6447 unsigned long SgOmpSimdlenClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6448 void SgOmpSimdlenClause_clearMemoryPool ( );
6449 void SgOmpSimdlenClause_extendMemoryPoolForFileIO ( );
6450 unsigned long SgOmpSimdlenClause_initializeStorageClassArray( SgOmpSimdlenClauseStorageClass *storageArray );
6451 void SgOmpSimdlenClause_resetValidFreepointers( );
6452 unsigned long SgOmpSimdlenClause_getNumberOfLastValidPointer();
6453 
6454 
6455 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6456 
6457 #include <semaphore.h>
6458 // DQ (9/21/2005): Static variables supporting memory pools
6465 extern int SgOmpFinalClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6466 
6471 extern SgOmpFinalClause* SgOmpFinalClause_Current_Link; // = NULL;
6472 
6473 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6474 // This is was one of the things on the todo list (above).
6475 
6480 extern std::vector < unsigned char* > SgOmpFinalClause_Memory_Block_List;
6481 /* */
6482 
6483 // DQ (4/6/2006): Newer code from Jochen
6484 // Methods to find the pointer to a global and local index
6485 SgOmpFinalClause* SgOmpFinalClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6486 SgOmpFinalClause* SgOmpFinalClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6487 
6488 // Methods for computing the total size of the memory pool. It actually returns the
6489 // size of the whole blocks allocated, no matter they contain valid pointers or not
6490 unsigned long SgOmpFinalClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6491 void SgOmpFinalClause_clearMemoryPool ( );
6492 void SgOmpFinalClause_extendMemoryPoolForFileIO ( );
6493 unsigned long SgOmpFinalClause_initializeStorageClassArray( SgOmpFinalClauseStorageClass *storageArray );
6494 void SgOmpFinalClause_resetValidFreepointers( );
6495 unsigned long SgOmpFinalClause_getNumberOfLastValidPointer();
6496 
6497 
6498 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6499 
6500 #include <semaphore.h>
6501 // DQ (9/21/2005): Static variables supporting memory pools
6508 extern int SgOmpPriorityClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6509 
6514 extern SgOmpPriorityClause* SgOmpPriorityClause_Current_Link; // = NULL;
6515 
6516 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6517 // This is was one of the things on the todo list (above).
6518 
6523 extern std::vector < unsigned char* > SgOmpPriorityClause_Memory_Block_List;
6524 /* */
6525 
6526 // DQ (4/6/2006): Newer code from Jochen
6527 // Methods to find the pointer to a global and local index
6528 SgOmpPriorityClause* SgOmpPriorityClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6529 SgOmpPriorityClause* SgOmpPriorityClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6530 
6531 // Methods for computing the total size of the memory pool. It actually returns the
6532 // size of the whole blocks allocated, no matter they contain valid pointers or not
6533 unsigned long SgOmpPriorityClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6534 void SgOmpPriorityClause_clearMemoryPool ( );
6535 void SgOmpPriorityClause_extendMemoryPoolForFileIO ( );
6536 unsigned long SgOmpPriorityClause_initializeStorageClassArray( SgOmpPriorityClauseStorageClass *storageArray );
6537 void SgOmpPriorityClause_resetValidFreepointers( );
6538 unsigned long SgOmpPriorityClause_getNumberOfLastValidPointer();
6539 
6540 
6541 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6542 
6543 #include <semaphore.h>
6544 // DQ (9/21/2005): Static variables supporting memory pools
6551 extern int SgOmpInbranchClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6552 
6557 extern SgOmpInbranchClause* SgOmpInbranchClause_Current_Link; // = NULL;
6558 
6559 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6560 // This is was one of the things on the todo list (above).
6561 
6566 extern std::vector < unsigned char* > SgOmpInbranchClause_Memory_Block_List;
6567 /* */
6568 
6569 // DQ (4/6/2006): Newer code from Jochen
6570 // Methods to find the pointer to a global and local index
6571 SgOmpInbranchClause* SgOmpInbranchClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6572 SgOmpInbranchClause* SgOmpInbranchClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6573 
6574 // Methods for computing the total size of the memory pool. It actually returns the
6575 // size of the whole blocks allocated, no matter they contain valid pointers or not
6576 unsigned long SgOmpInbranchClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6577 void SgOmpInbranchClause_clearMemoryPool ( );
6578 void SgOmpInbranchClause_extendMemoryPoolForFileIO ( );
6579 unsigned long SgOmpInbranchClause_initializeStorageClassArray( SgOmpInbranchClauseStorageClass *storageArray );
6580 void SgOmpInbranchClause_resetValidFreepointers( );
6581 unsigned long SgOmpInbranchClause_getNumberOfLastValidPointer();
6582 
6583 
6584 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6585 
6586 #include <semaphore.h>
6587 // DQ (9/21/2005): Static variables supporting memory pools
6594 extern int SgOmpNotinbranchClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6595 
6600 extern SgOmpNotinbranchClause* SgOmpNotinbranchClause_Current_Link; // = NULL;
6601 
6602 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6603 // This is was one of the things on the todo list (above).
6604 
6609 extern std::vector < unsigned char* > SgOmpNotinbranchClause_Memory_Block_List;
6610 /* */
6611 
6612 // DQ (4/6/2006): Newer code from Jochen
6613 // Methods to find the pointer to a global and local index
6614 SgOmpNotinbranchClause* SgOmpNotinbranchClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6615 SgOmpNotinbranchClause* SgOmpNotinbranchClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6616 
6617 // Methods for computing the total size of the memory pool. It actually returns the
6618 // size of the whole blocks allocated, no matter they contain valid pointers or not
6619 unsigned long SgOmpNotinbranchClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6620 void SgOmpNotinbranchClause_clearMemoryPool ( );
6621 void SgOmpNotinbranchClause_extendMemoryPoolForFileIO ( );
6622 unsigned long SgOmpNotinbranchClause_initializeStorageClassArray( SgOmpNotinbranchClauseStorageClass *storageArray );
6623 void SgOmpNotinbranchClause_resetValidFreepointers( );
6624 unsigned long SgOmpNotinbranchClause_getNumberOfLastValidPointer();
6625 
6626 
6627 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6628 
6629 #include <semaphore.h>
6630 // DQ (9/21/2005): Static variables supporting memory pools
6637 extern int SgOmpVariablesClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6638 
6643 extern SgOmpVariablesClause* SgOmpVariablesClause_Current_Link; // = NULL;
6644 
6645 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6646 // This is was one of the things on the todo list (above).
6647 
6652 extern std::vector < unsigned char* > SgOmpVariablesClause_Memory_Block_List;
6653 /* */
6654 
6655 // DQ (4/6/2006): Newer code from Jochen
6656 // Methods to find the pointer to a global and local index
6657 SgOmpVariablesClause* SgOmpVariablesClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6658 SgOmpVariablesClause* SgOmpVariablesClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6659 
6660 // Methods for computing the total size of the memory pool. It actually returns the
6661 // size of the whole blocks allocated, no matter they contain valid pointers or not
6662 unsigned long SgOmpVariablesClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6663 void SgOmpVariablesClause_clearMemoryPool ( );
6664 void SgOmpVariablesClause_extendMemoryPoolForFileIO ( );
6665 unsigned long SgOmpVariablesClause_initializeStorageClassArray( SgOmpVariablesClauseStorageClass *storageArray );
6666 void SgOmpVariablesClause_resetValidFreepointers( );
6667 unsigned long SgOmpVariablesClause_getNumberOfLastValidPointer();
6668 
6669 
6670 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6671 
6672 #include <semaphore.h>
6673 // DQ (9/21/2005): Static variables supporting memory pools
6680 extern int SgOmpCopyprivateClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6681 
6686 extern SgOmpCopyprivateClause* SgOmpCopyprivateClause_Current_Link; // = NULL;
6687 
6688 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6689 // This is was one of the things on the todo list (above).
6690 
6695 extern std::vector < unsigned char* > SgOmpCopyprivateClause_Memory_Block_List;
6696 /* */
6697 
6698 // DQ (4/6/2006): Newer code from Jochen
6699 // Methods to find the pointer to a global and local index
6700 SgOmpCopyprivateClause* SgOmpCopyprivateClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6701 SgOmpCopyprivateClause* SgOmpCopyprivateClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6702 
6703 // Methods for computing the total size of the memory pool. It actually returns the
6704 // size of the whole blocks allocated, no matter they contain valid pointers or not
6705 unsigned long SgOmpCopyprivateClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6706 void SgOmpCopyprivateClause_clearMemoryPool ( );
6707 void SgOmpCopyprivateClause_extendMemoryPoolForFileIO ( );
6708 unsigned long SgOmpCopyprivateClause_initializeStorageClassArray( SgOmpCopyprivateClauseStorageClass *storageArray );
6709 void SgOmpCopyprivateClause_resetValidFreepointers( );
6710 unsigned long SgOmpCopyprivateClause_getNumberOfLastValidPointer();
6711 
6712 
6713 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6714 
6715 #include <semaphore.h>
6716 // DQ (9/21/2005): Static variables supporting memory pools
6723 extern int SgOmpPrivateClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6724 
6729 extern SgOmpPrivateClause* SgOmpPrivateClause_Current_Link; // = NULL;
6730 
6731 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6732 // This is was one of the things on the todo list (above).
6733 
6738 extern std::vector < unsigned char* > SgOmpPrivateClause_Memory_Block_List;
6739 /* */
6740 
6741 // DQ (4/6/2006): Newer code from Jochen
6742 // Methods to find the pointer to a global and local index
6743 SgOmpPrivateClause* SgOmpPrivateClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6744 SgOmpPrivateClause* SgOmpPrivateClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6745 
6746 // Methods for computing the total size of the memory pool. It actually returns the
6747 // size of the whole blocks allocated, no matter they contain valid pointers or not
6748 unsigned long SgOmpPrivateClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6749 void SgOmpPrivateClause_clearMemoryPool ( );
6750 void SgOmpPrivateClause_extendMemoryPoolForFileIO ( );
6751 unsigned long SgOmpPrivateClause_initializeStorageClassArray( SgOmpPrivateClauseStorageClass *storageArray );
6752 void SgOmpPrivateClause_resetValidFreepointers( );
6753 unsigned long SgOmpPrivateClause_getNumberOfLastValidPointer();
6754 
6755 
6756 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6757 
6758 #include <semaphore.h>
6759 // DQ (9/21/2005): Static variables supporting memory pools
6766 extern int SgOmpFirstprivateClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6767 
6772 extern SgOmpFirstprivateClause* SgOmpFirstprivateClause_Current_Link; // = NULL;
6773 
6774 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6775 // This is was one of the things on the todo list (above).
6776 
6781 extern std::vector < unsigned char* > SgOmpFirstprivateClause_Memory_Block_List;
6782 /* */
6783 
6784 // DQ (4/6/2006): Newer code from Jochen
6785 // Methods to find the pointer to a global and local index
6786 SgOmpFirstprivateClause* SgOmpFirstprivateClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6787 SgOmpFirstprivateClause* SgOmpFirstprivateClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6788 
6789 // Methods for computing the total size of the memory pool. It actually returns the
6790 // size of the whole blocks allocated, no matter they contain valid pointers or not
6791 unsigned long SgOmpFirstprivateClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6792 void SgOmpFirstprivateClause_clearMemoryPool ( );
6793 void SgOmpFirstprivateClause_extendMemoryPoolForFileIO ( );
6794 unsigned long SgOmpFirstprivateClause_initializeStorageClassArray( SgOmpFirstprivateClauseStorageClass *storageArray );
6795 void SgOmpFirstprivateClause_resetValidFreepointers( );
6796 unsigned long SgOmpFirstprivateClause_getNumberOfLastValidPointer();
6797 
6798 
6799 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6800 
6801 #include <semaphore.h>
6802 // DQ (9/21/2005): Static variables supporting memory pools
6809 extern int SgOmpSharedClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6810 
6815 extern SgOmpSharedClause* SgOmpSharedClause_Current_Link; // = NULL;
6816 
6817 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6818 // This is was one of the things on the todo list (above).
6819 
6824 extern std::vector < unsigned char* > SgOmpSharedClause_Memory_Block_List;
6825 /* */
6826 
6827 // DQ (4/6/2006): Newer code from Jochen
6828 // Methods to find the pointer to a global and local index
6829 SgOmpSharedClause* SgOmpSharedClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6830 SgOmpSharedClause* SgOmpSharedClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6831 
6832 // Methods for computing the total size of the memory pool. It actually returns the
6833 // size of the whole blocks allocated, no matter they contain valid pointers or not
6834 unsigned long SgOmpSharedClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6835 void SgOmpSharedClause_clearMemoryPool ( );
6836 void SgOmpSharedClause_extendMemoryPoolForFileIO ( );
6837 unsigned long SgOmpSharedClause_initializeStorageClassArray( SgOmpSharedClauseStorageClass *storageArray );
6838 void SgOmpSharedClause_resetValidFreepointers( );
6839 unsigned long SgOmpSharedClause_getNumberOfLastValidPointer();
6840 
6841 
6842 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6843 
6844 #include <semaphore.h>
6845 // DQ (9/21/2005): Static variables supporting memory pools
6852 extern int SgOmpCopyinClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6853 
6858 extern SgOmpCopyinClause* SgOmpCopyinClause_Current_Link; // = NULL;
6859 
6860 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6861 // This is was one of the things on the todo list (above).
6862 
6867 extern std::vector < unsigned char* > SgOmpCopyinClause_Memory_Block_List;
6868 /* */
6869 
6870 // DQ (4/6/2006): Newer code from Jochen
6871 // Methods to find the pointer to a global and local index
6872 SgOmpCopyinClause* SgOmpCopyinClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6873 SgOmpCopyinClause* SgOmpCopyinClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6874 
6875 // Methods for computing the total size of the memory pool. It actually returns the
6876 // size of the whole blocks allocated, no matter they contain valid pointers or not
6877 unsigned long SgOmpCopyinClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6878 void SgOmpCopyinClause_clearMemoryPool ( );
6879 void SgOmpCopyinClause_extendMemoryPoolForFileIO ( );
6880 unsigned long SgOmpCopyinClause_initializeStorageClassArray( SgOmpCopyinClauseStorageClass *storageArray );
6881 void SgOmpCopyinClause_resetValidFreepointers( );
6882 unsigned long SgOmpCopyinClause_getNumberOfLastValidPointer();
6883 
6884 
6885 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6886 
6887 #include <semaphore.h>
6888 // DQ (9/21/2005): Static variables supporting memory pools
6895 extern int SgOmpLastprivateClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6896 
6901 extern SgOmpLastprivateClause* SgOmpLastprivateClause_Current_Link; // = NULL;
6902 
6903 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6904 // This is was one of the things on the todo list (above).
6905 
6910 extern std::vector < unsigned char* > SgOmpLastprivateClause_Memory_Block_List;
6911 /* */
6912 
6913 // DQ (4/6/2006): Newer code from Jochen
6914 // Methods to find the pointer to a global and local index
6915 SgOmpLastprivateClause* SgOmpLastprivateClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6916 SgOmpLastprivateClause* SgOmpLastprivateClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6917 
6918 // Methods for computing the total size of the memory pool. It actually returns the
6919 // size of the whole blocks allocated, no matter they contain valid pointers or not
6920 unsigned long SgOmpLastprivateClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6921 void SgOmpLastprivateClause_clearMemoryPool ( );
6922 void SgOmpLastprivateClause_extendMemoryPoolForFileIO ( );
6923 unsigned long SgOmpLastprivateClause_initializeStorageClassArray( SgOmpLastprivateClauseStorageClass *storageArray );
6924 void SgOmpLastprivateClause_resetValidFreepointers( );
6925 unsigned long SgOmpLastprivateClause_getNumberOfLastValidPointer();
6926 
6927 
6928 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6929 
6930 #include <semaphore.h>
6931 // DQ (9/21/2005): Static variables supporting memory pools
6938 extern int SgOmpReductionClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6939 
6944 extern SgOmpReductionClause* SgOmpReductionClause_Current_Link; // = NULL;
6945 
6946 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6947 // This is was one of the things on the todo list (above).
6948 
6953 extern std::vector < unsigned char* > SgOmpReductionClause_Memory_Block_List;
6954 /* */
6955 
6956 // DQ (4/6/2006): Newer code from Jochen
6957 // Methods to find the pointer to a global and local index
6958 SgOmpReductionClause* SgOmpReductionClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
6959 SgOmpReductionClause* SgOmpReductionClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
6960 
6961 // Methods for computing the total size of the memory pool. It actually returns the
6962 // size of the whole blocks allocated, no matter they contain valid pointers or not
6963 unsigned long SgOmpReductionClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
6964 void SgOmpReductionClause_clearMemoryPool ( );
6965 void SgOmpReductionClause_extendMemoryPoolForFileIO ( );
6966 unsigned long SgOmpReductionClause_initializeStorageClassArray( SgOmpReductionClauseStorageClass *storageArray );
6967 void SgOmpReductionClause_resetValidFreepointers( );
6968 unsigned long SgOmpReductionClause_getNumberOfLastValidPointer();
6969 
6970 
6971 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
6972 
6973 #include <semaphore.h>
6974 // DQ (9/21/2005): Static variables supporting memory pools
6981 extern int SgOmpMapClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
6982 
6987 extern SgOmpMapClause* SgOmpMapClause_Current_Link; // = NULL;
6988 
6989 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
6990 // This is was one of the things on the todo list (above).
6991 
6996 extern std::vector < unsigned char* > SgOmpMapClause_Memory_Block_List;
6997 /* */
6998 
6999 // DQ (4/6/2006): Newer code from Jochen
7000 // Methods to find the pointer to a global and local index
7001 SgOmpMapClause* SgOmpMapClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7002 SgOmpMapClause* SgOmpMapClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7003 
7004 // Methods for computing the total size of the memory pool. It actually returns the
7005 // size of the whole blocks allocated, no matter they contain valid pointers or not
7006 unsigned long SgOmpMapClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7007 void SgOmpMapClause_clearMemoryPool ( );
7008 void SgOmpMapClause_extendMemoryPoolForFileIO ( );
7009 unsigned long SgOmpMapClause_initializeStorageClassArray( SgOmpMapClauseStorageClass *storageArray );
7010 void SgOmpMapClause_resetValidFreepointers( );
7011 unsigned long SgOmpMapClause_getNumberOfLastValidPointer();
7012 
7013 
7014 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7015 
7016 #include <semaphore.h>
7017 // DQ (9/21/2005): Static variables supporting memory pools
7024 extern int SgOmpUniformClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7025 
7030 extern SgOmpUniformClause* SgOmpUniformClause_Current_Link; // = NULL;
7031 
7032 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7033 // This is was one of the things on the todo list (above).
7034 
7039 extern std::vector < unsigned char* > SgOmpUniformClause_Memory_Block_List;
7040 /* */
7041 
7042 // DQ (4/6/2006): Newer code from Jochen
7043 // Methods to find the pointer to a global and local index
7044 SgOmpUniformClause* SgOmpUniformClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7045 SgOmpUniformClause* SgOmpUniformClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7046 
7047 // Methods for computing the total size of the memory pool. It actually returns the
7048 // size of the whole blocks allocated, no matter they contain valid pointers or not
7049 unsigned long SgOmpUniformClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7050 void SgOmpUniformClause_clearMemoryPool ( );
7051 void SgOmpUniformClause_extendMemoryPoolForFileIO ( );
7052 unsigned long SgOmpUniformClause_initializeStorageClassArray( SgOmpUniformClauseStorageClass *storageArray );
7053 void SgOmpUniformClause_resetValidFreepointers( );
7054 unsigned long SgOmpUniformClause_getNumberOfLastValidPointer();
7055 
7056 
7057 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7058 
7059 #include <semaphore.h>
7060 // DQ (9/21/2005): Static variables supporting memory pools
7067 extern int SgOmpAlignedClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7068 
7073 extern SgOmpAlignedClause* SgOmpAlignedClause_Current_Link; // = NULL;
7074 
7075 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7076 // This is was one of the things on the todo list (above).
7077 
7082 extern std::vector < unsigned char* > SgOmpAlignedClause_Memory_Block_List;
7083 /* */
7084 
7085 // DQ (4/6/2006): Newer code from Jochen
7086 // Methods to find the pointer to a global and local index
7087 SgOmpAlignedClause* SgOmpAlignedClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7088 SgOmpAlignedClause* SgOmpAlignedClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7089 
7090 // Methods for computing the total size of the memory pool. It actually returns the
7091 // size of the whole blocks allocated, no matter they contain valid pointers or not
7092 unsigned long SgOmpAlignedClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7093 void SgOmpAlignedClause_clearMemoryPool ( );
7094 void SgOmpAlignedClause_extendMemoryPoolForFileIO ( );
7095 unsigned long SgOmpAlignedClause_initializeStorageClassArray( SgOmpAlignedClauseStorageClass *storageArray );
7096 void SgOmpAlignedClause_resetValidFreepointers( );
7097 unsigned long SgOmpAlignedClause_getNumberOfLastValidPointer();
7098 
7099 
7100 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7101 
7102 #include <semaphore.h>
7103 // DQ (9/21/2005): Static variables supporting memory pools
7110 extern int SgOmpLinearClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7111 
7116 extern SgOmpLinearClause* SgOmpLinearClause_Current_Link; // = NULL;
7117 
7118 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7119 // This is was one of the things on the todo list (above).
7120 
7125 extern std::vector < unsigned char* > SgOmpLinearClause_Memory_Block_List;
7126 /* */
7127 
7128 // DQ (4/6/2006): Newer code from Jochen
7129 // Methods to find the pointer to a global and local index
7130 SgOmpLinearClause* SgOmpLinearClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7131 SgOmpLinearClause* SgOmpLinearClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7132 
7133 // Methods for computing the total size of the memory pool. It actually returns the
7134 // size of the whole blocks allocated, no matter they contain valid pointers or not
7135 unsigned long SgOmpLinearClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7136 void SgOmpLinearClause_clearMemoryPool ( );
7137 void SgOmpLinearClause_extendMemoryPoolForFileIO ( );
7138 unsigned long SgOmpLinearClause_initializeStorageClassArray( SgOmpLinearClauseStorageClass *storageArray );
7139 void SgOmpLinearClause_resetValidFreepointers( );
7140 unsigned long SgOmpLinearClause_getNumberOfLastValidPointer();
7141 
7142 
7143 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7144 
7145 #include <semaphore.h>
7146 // DQ (9/21/2005): Static variables supporting memory pools
7153 extern int SgOmpDependClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7154 
7159 extern SgOmpDependClause* SgOmpDependClause_Current_Link; // = NULL;
7160 
7161 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7162 // This is was one of the things on the todo list (above).
7163 
7168 extern std::vector < unsigned char* > SgOmpDependClause_Memory_Block_List;
7169 /* */
7170 
7171 // DQ (4/6/2006): Newer code from Jochen
7172 // Methods to find the pointer to a global and local index
7173 SgOmpDependClause* SgOmpDependClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7174 SgOmpDependClause* SgOmpDependClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7175 
7176 // Methods for computing the total size of the memory pool. It actually returns the
7177 // size of the whole blocks allocated, no matter they contain valid pointers or not
7178 unsigned long SgOmpDependClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7179 void SgOmpDependClause_clearMemoryPool ( );
7180 void SgOmpDependClause_extendMemoryPoolForFileIO ( );
7181 unsigned long SgOmpDependClause_initializeStorageClassArray( SgOmpDependClauseStorageClass *storageArray );
7182 void SgOmpDependClause_resetValidFreepointers( );
7183 unsigned long SgOmpDependClause_getNumberOfLastValidPointer();
7184 
7185 
7186 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7187 
7188 #include <semaphore.h>
7189 // DQ (9/21/2005): Static variables supporting memory pools
7196 extern int SgOmpScheduleClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7197 
7202 extern SgOmpScheduleClause* SgOmpScheduleClause_Current_Link; // = NULL;
7203 
7204 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7205 // This is was one of the things on the todo list (above).
7206 
7211 extern std::vector < unsigned char* > SgOmpScheduleClause_Memory_Block_List;
7212 /* */
7213 
7214 // DQ (4/6/2006): Newer code from Jochen
7215 // Methods to find the pointer to a global and local index
7216 SgOmpScheduleClause* SgOmpScheduleClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7217 SgOmpScheduleClause* SgOmpScheduleClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7218 
7219 // Methods for computing the total size of the memory pool. It actually returns the
7220 // size of the whole blocks allocated, no matter they contain valid pointers or not
7221 unsigned long SgOmpScheduleClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7222 void SgOmpScheduleClause_clearMemoryPool ( );
7223 void SgOmpScheduleClause_extendMemoryPoolForFileIO ( );
7224 unsigned long SgOmpScheduleClause_initializeStorageClassArray( SgOmpScheduleClauseStorageClass *storageArray );
7225 void SgOmpScheduleClause_resetValidFreepointers( );
7226 unsigned long SgOmpScheduleClause_getNumberOfLastValidPointer();
7227 
7228 
7229 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7230 
7231 #include <semaphore.h>
7232 // DQ (9/21/2005): Static variables supporting memory pools
7239 extern int SgOmpMergeableClause_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7240 
7245 extern SgOmpMergeableClause* SgOmpMergeableClause_Current_Link; // = NULL;
7246 
7247 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7248 // This is was one of the things on the todo list (above).
7249 
7254 extern std::vector < unsigned char* > SgOmpMergeableClause_Memory_Block_List;
7255 /* */
7256 
7257 // DQ (4/6/2006): Newer code from Jochen
7258 // Methods to find the pointer to a global and local index
7259 SgOmpMergeableClause* SgOmpMergeableClause_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7260 SgOmpMergeableClause* SgOmpMergeableClause_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7261 
7262 // Methods for computing the total size of the memory pool. It actually returns the
7263 // size of the whole blocks allocated, no matter they contain valid pointers or not
7264 unsigned long SgOmpMergeableClause_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7265 void SgOmpMergeableClause_clearMemoryPool ( );
7266 void SgOmpMergeableClause_extendMemoryPoolForFileIO ( );
7267 unsigned long SgOmpMergeableClause_initializeStorageClassArray( SgOmpMergeableClauseStorageClass *storageArray );
7268 void SgOmpMergeableClause_resetValidFreepointers( );
7269 unsigned long SgOmpMergeableClause_getNumberOfLastValidPointer();
7270 
7271 
7272 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7273 
7274 #include <semaphore.h>
7275 // DQ (9/21/2005): Static variables supporting memory pools
7282 extern int SgUntypedNode_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7283 
7288 extern SgUntypedNode* SgUntypedNode_Current_Link; // = NULL;
7289 
7290 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7291 // This is was one of the things on the todo list (above).
7292 
7297 extern std::vector < unsigned char* > SgUntypedNode_Memory_Block_List;
7298 /* */
7299 
7300 // DQ (4/6/2006): Newer code from Jochen
7301 // Methods to find the pointer to a global and local index
7302 SgUntypedNode* SgUntypedNode_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7303 SgUntypedNode* SgUntypedNode_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7304 
7305 // Methods for computing the total size of the memory pool. It actually returns the
7306 // size of the whole blocks allocated, no matter they contain valid pointers or not
7307 unsigned long SgUntypedNode_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7308 void SgUntypedNode_clearMemoryPool ( );
7309 void SgUntypedNode_extendMemoryPoolForFileIO ( );
7310 unsigned long SgUntypedNode_initializeStorageClassArray( SgUntypedNodeStorageClass *storageArray );
7311 void SgUntypedNode_resetValidFreepointers( );
7312 unsigned long SgUntypedNode_getNumberOfLastValidPointer();
7313 
7314 
7315 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7316 
7317 #include <semaphore.h>
7318 // DQ (9/21/2005): Static variables supporting memory pools
7325 extern int SgUntypedExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7326 
7331 extern SgUntypedExpression* SgUntypedExpression_Current_Link; // = NULL;
7332 
7333 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7334 // This is was one of the things on the todo list (above).
7335 
7340 extern std::vector < unsigned char* > SgUntypedExpression_Memory_Block_List;
7341 /* */
7342 
7343 // DQ (4/6/2006): Newer code from Jochen
7344 // Methods to find the pointer to a global and local index
7345 SgUntypedExpression* SgUntypedExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7346 SgUntypedExpression* SgUntypedExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7347 
7348 // Methods for computing the total size of the memory pool. It actually returns the
7349 // size of the whole blocks allocated, no matter they contain valid pointers or not
7350 unsigned long SgUntypedExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7351 void SgUntypedExpression_clearMemoryPool ( );
7352 void SgUntypedExpression_extendMemoryPoolForFileIO ( );
7353 unsigned long SgUntypedExpression_initializeStorageClassArray( SgUntypedExpressionStorageClass *storageArray );
7354 void SgUntypedExpression_resetValidFreepointers( );
7355 unsigned long SgUntypedExpression_getNumberOfLastValidPointer();
7356 
7357 
7358 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7359 
7360 #include <semaphore.h>
7361 // DQ (9/21/2005): Static variables supporting memory pools
7368 extern int SgUntypedUnaryOperator_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7369 
7374 extern SgUntypedUnaryOperator* SgUntypedUnaryOperator_Current_Link; // = NULL;
7375 
7376 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7377 // This is was one of the things on the todo list (above).
7378 
7383 extern std::vector < unsigned char* > SgUntypedUnaryOperator_Memory_Block_List;
7384 /* */
7385 
7386 // DQ (4/6/2006): Newer code from Jochen
7387 // Methods to find the pointer to a global and local index
7388 SgUntypedUnaryOperator* SgUntypedUnaryOperator_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7389 SgUntypedUnaryOperator* SgUntypedUnaryOperator_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7390 
7391 // Methods for computing the total size of the memory pool. It actually returns the
7392 // size of the whole blocks allocated, no matter they contain valid pointers or not
7393 unsigned long SgUntypedUnaryOperator_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7394 void SgUntypedUnaryOperator_clearMemoryPool ( );
7395 void SgUntypedUnaryOperator_extendMemoryPoolForFileIO ( );
7396 unsigned long SgUntypedUnaryOperator_initializeStorageClassArray( SgUntypedUnaryOperatorStorageClass *storageArray );
7397 void SgUntypedUnaryOperator_resetValidFreepointers( );
7398 unsigned long SgUntypedUnaryOperator_getNumberOfLastValidPointer();
7399 
7400 
7401 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7402 
7403 #include <semaphore.h>
7404 // DQ (9/21/2005): Static variables supporting memory pools
7411 extern int SgUntypedBinaryOperator_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7412 
7417 extern SgUntypedBinaryOperator* SgUntypedBinaryOperator_Current_Link; // = NULL;
7418 
7419 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7420 // This is was one of the things on the todo list (above).
7421 
7426 extern std::vector < unsigned char* > SgUntypedBinaryOperator_Memory_Block_List;
7427 /* */
7428 
7429 // DQ (4/6/2006): Newer code from Jochen
7430 // Methods to find the pointer to a global and local index
7431 SgUntypedBinaryOperator* SgUntypedBinaryOperator_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7432 SgUntypedBinaryOperator* SgUntypedBinaryOperator_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7433 
7434 // Methods for computing the total size of the memory pool. It actually returns the
7435 // size of the whole blocks allocated, no matter they contain valid pointers or not
7436 unsigned long SgUntypedBinaryOperator_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7437 void SgUntypedBinaryOperator_clearMemoryPool ( );
7438 void SgUntypedBinaryOperator_extendMemoryPoolForFileIO ( );
7439 unsigned long SgUntypedBinaryOperator_initializeStorageClassArray( SgUntypedBinaryOperatorStorageClass *storageArray );
7440 void SgUntypedBinaryOperator_resetValidFreepointers( );
7441 unsigned long SgUntypedBinaryOperator_getNumberOfLastValidPointer();
7442 
7443 
7444 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7445 
7446 #include <semaphore.h>
7447 // DQ (9/21/2005): Static variables supporting memory pools
7454 extern int SgUntypedValueExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7455 
7460 extern SgUntypedValueExpression* SgUntypedValueExpression_Current_Link; // = NULL;
7461 
7462 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7463 // This is was one of the things on the todo list (above).
7464 
7469 extern std::vector < unsigned char* > SgUntypedValueExpression_Memory_Block_List;
7470 /* */
7471 
7472 // DQ (4/6/2006): Newer code from Jochen
7473 // Methods to find the pointer to a global and local index
7474 SgUntypedValueExpression* SgUntypedValueExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7475 SgUntypedValueExpression* SgUntypedValueExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7476 
7477 // Methods for computing the total size of the memory pool. It actually returns the
7478 // size of the whole blocks allocated, no matter they contain valid pointers or not
7479 unsigned long SgUntypedValueExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7480 void SgUntypedValueExpression_clearMemoryPool ( );
7481 void SgUntypedValueExpression_extendMemoryPoolForFileIO ( );
7482 unsigned long SgUntypedValueExpression_initializeStorageClassArray( SgUntypedValueExpressionStorageClass *storageArray );
7483 void SgUntypedValueExpression_resetValidFreepointers( );
7484 unsigned long SgUntypedValueExpression_getNumberOfLastValidPointer();
7485 
7486 
7487 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7488 
7489 #include <semaphore.h>
7490 // DQ (9/21/2005): Static variables supporting memory pools
7497 extern int SgUntypedArrayReferenceExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7498 
7503 extern SgUntypedArrayReferenceExpression* SgUntypedArrayReferenceExpression_Current_Link; // = NULL;
7504 
7505 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7506 // This is was one of the things on the todo list (above).
7507 
7512 extern std::vector < unsigned char* > SgUntypedArrayReferenceExpression_Memory_Block_List;
7513 /* */
7514 
7515 // DQ (4/6/2006): Newer code from Jochen
7516 // Methods to find the pointer to a global and local index
7517 SgUntypedArrayReferenceExpression* SgUntypedArrayReferenceExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7518 SgUntypedArrayReferenceExpression* SgUntypedArrayReferenceExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7519 
7520 // Methods for computing the total size of the memory pool. It actually returns the
7521 // size of the whole blocks allocated, no matter they contain valid pointers or not
7522 unsigned long SgUntypedArrayReferenceExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7523 void SgUntypedArrayReferenceExpression_clearMemoryPool ( );
7524 void SgUntypedArrayReferenceExpression_extendMemoryPoolForFileIO ( );
7525 unsigned long SgUntypedArrayReferenceExpression_initializeStorageClassArray( SgUntypedArrayReferenceExpressionStorageClass *storageArray );
7526 void SgUntypedArrayReferenceExpression_resetValidFreepointers( );
7527 unsigned long SgUntypedArrayReferenceExpression_getNumberOfLastValidPointer();
7528 
7529 
7530 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7531 
7532 #include <semaphore.h>
7533 // DQ (9/21/2005): Static variables supporting memory pools
7540 extern int SgUntypedOtherExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7541 
7546 extern SgUntypedOtherExpression* SgUntypedOtherExpression_Current_Link; // = NULL;
7547 
7548 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7549 // This is was one of the things on the todo list (above).
7550 
7555 extern std::vector < unsigned char* > SgUntypedOtherExpression_Memory_Block_List;
7556 /* */
7557 
7558 // DQ (4/6/2006): Newer code from Jochen
7559 // Methods to find the pointer to a global and local index
7560 SgUntypedOtherExpression* SgUntypedOtherExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7561 SgUntypedOtherExpression* SgUntypedOtherExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7562 
7563 // Methods for computing the total size of the memory pool. It actually returns the
7564 // size of the whole blocks allocated, no matter they contain valid pointers or not
7565 unsigned long SgUntypedOtherExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7566 void SgUntypedOtherExpression_clearMemoryPool ( );
7567 void SgUntypedOtherExpression_extendMemoryPoolForFileIO ( );
7568 unsigned long SgUntypedOtherExpression_initializeStorageClassArray( SgUntypedOtherExpressionStorageClass *storageArray );
7569 void SgUntypedOtherExpression_resetValidFreepointers( );
7570 unsigned long SgUntypedOtherExpression_getNumberOfLastValidPointer();
7571 
7572 
7573 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7574 
7575 #include <semaphore.h>
7576 // DQ (9/21/2005): Static variables supporting memory pools
7583 extern int SgUntypedFunctionCallOrArrayReferenceExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7584 
7589 extern SgUntypedFunctionCallOrArrayReferenceExpression* SgUntypedFunctionCallOrArrayReferenceExpression_Current_Link; // = NULL;
7590 
7591 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7592 // This is was one of the things on the todo list (above).
7593 
7598 extern std::vector < unsigned char* > SgUntypedFunctionCallOrArrayReferenceExpression_Memory_Block_List;
7599 /* */
7600 
7601 // DQ (4/6/2006): Newer code from Jochen
7602 // Methods to find the pointer to a global and local index
7603 SgUntypedFunctionCallOrArrayReferenceExpression* SgUntypedFunctionCallOrArrayReferenceExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7604 SgUntypedFunctionCallOrArrayReferenceExpression* SgUntypedFunctionCallOrArrayReferenceExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7605 
7606 // Methods for computing the total size of the memory pool. It actually returns the
7607 // size of the whole blocks allocated, no matter they contain valid pointers or not
7608 unsigned long SgUntypedFunctionCallOrArrayReferenceExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7609 void SgUntypedFunctionCallOrArrayReferenceExpression_clearMemoryPool ( );
7610 void SgUntypedFunctionCallOrArrayReferenceExpression_extendMemoryPoolForFileIO ( );
7611 unsigned long SgUntypedFunctionCallOrArrayReferenceExpression_initializeStorageClassArray( SgUntypedFunctionCallOrArrayReferenceExpressionStorageClass *storageArray );
7612 void SgUntypedFunctionCallOrArrayReferenceExpression_resetValidFreepointers( );
7613 unsigned long SgUntypedFunctionCallOrArrayReferenceExpression_getNumberOfLastValidPointer();
7614 
7615 
7616 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7617 
7618 #include <semaphore.h>
7619 // DQ (9/21/2005): Static variables supporting memory pools
7626 extern int SgUntypedReferenceExpression_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7627 
7632 extern SgUntypedReferenceExpression* SgUntypedReferenceExpression_Current_Link; // = NULL;
7633 
7634 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7635 // This is was one of the things on the todo list (above).
7636 
7641 extern std::vector < unsigned char* > SgUntypedReferenceExpression_Memory_Block_List;
7642 /* */
7643 
7644 // DQ (4/6/2006): Newer code from Jochen
7645 // Methods to find the pointer to a global and local index
7646 SgUntypedReferenceExpression* SgUntypedReferenceExpression_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7647 SgUntypedReferenceExpression* SgUntypedReferenceExpression_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7648 
7649 // Methods for computing the total size of the memory pool. It actually returns the
7650 // size of the whole blocks allocated, no matter they contain valid pointers or not
7651 unsigned long SgUntypedReferenceExpression_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7652 void SgUntypedReferenceExpression_clearMemoryPool ( );
7653 void SgUntypedReferenceExpression_extendMemoryPoolForFileIO ( );
7654 unsigned long SgUntypedReferenceExpression_initializeStorageClassArray( SgUntypedReferenceExpressionStorageClass *storageArray );
7655 void SgUntypedReferenceExpression_resetValidFreepointers( );
7656 unsigned long SgUntypedReferenceExpression_getNumberOfLastValidPointer();
7657 
7658 
7659 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7660 
7661 #include <semaphore.h>
7662 // DQ (9/21/2005): Static variables supporting memory pools
7669 extern int SgUntypedStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7670 
7675 extern SgUntypedStatement* SgUntypedStatement_Current_Link; // = NULL;
7676 
7677 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7678 // This is was one of the things on the todo list (above).
7679 
7684 extern std::vector < unsigned char* > SgUntypedStatement_Memory_Block_List;
7685 /* */
7686 
7687 // DQ (4/6/2006): Newer code from Jochen
7688 // Methods to find the pointer to a global and local index
7689 SgUntypedStatement* SgUntypedStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7690 SgUntypedStatement* SgUntypedStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7691 
7692 // Methods for computing the total size of the memory pool. It actually returns the
7693 // size of the whole blocks allocated, no matter they contain valid pointers or not
7694 unsigned long SgUntypedStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7695 void SgUntypedStatement_clearMemoryPool ( );
7696 void SgUntypedStatement_extendMemoryPoolForFileIO ( );
7697 unsigned long SgUntypedStatement_initializeStorageClassArray( SgUntypedStatementStorageClass *storageArray );
7698 void SgUntypedStatement_resetValidFreepointers( );
7699 unsigned long SgUntypedStatement_getNumberOfLastValidPointer();
7700 
7701 
7702 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7703 
7704 #include <semaphore.h>
7705 // DQ (9/21/2005): Static variables supporting memory pools
7712 extern int SgUntypedDeclarationStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7713 
7718 extern SgUntypedDeclarationStatement* SgUntypedDeclarationStatement_Current_Link; // = NULL;
7719 
7720 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7721 // This is was one of the things on the todo list (above).
7722 
7727 extern std::vector < unsigned char* > SgUntypedDeclarationStatement_Memory_Block_List;
7728 /* */
7729 
7730 // DQ (4/6/2006): Newer code from Jochen
7731 // Methods to find the pointer to a global and local index
7732 SgUntypedDeclarationStatement* SgUntypedDeclarationStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7733 SgUntypedDeclarationStatement* SgUntypedDeclarationStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7734 
7735 // Methods for computing the total size of the memory pool. It actually returns the
7736 // size of the whole blocks allocated, no matter they contain valid pointers or not
7737 unsigned long SgUntypedDeclarationStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7738 void SgUntypedDeclarationStatement_clearMemoryPool ( );
7739 void SgUntypedDeclarationStatement_extendMemoryPoolForFileIO ( );
7740 unsigned long SgUntypedDeclarationStatement_initializeStorageClassArray( SgUntypedDeclarationStatementStorageClass *storageArray );
7741 void SgUntypedDeclarationStatement_resetValidFreepointers( );
7742 unsigned long SgUntypedDeclarationStatement_getNumberOfLastValidPointer();
7743 
7744 
7745 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7746 
7747 #include <semaphore.h>
7748 // DQ (9/21/2005): Static variables supporting memory pools
7755 extern int SgUntypedNameListDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7756 
7761 extern SgUntypedNameListDeclaration* SgUntypedNameListDeclaration_Current_Link; // = NULL;
7762 
7763 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7764 // This is was one of the things on the todo list (above).
7765 
7770 extern std::vector < unsigned char* > SgUntypedNameListDeclaration_Memory_Block_List;
7771 /* */
7772 
7773 // DQ (4/6/2006): Newer code from Jochen
7774 // Methods to find the pointer to a global and local index
7775 SgUntypedNameListDeclaration* SgUntypedNameListDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7776 SgUntypedNameListDeclaration* SgUntypedNameListDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7777 
7778 // Methods for computing the total size of the memory pool. It actually returns the
7779 // size of the whole blocks allocated, no matter they contain valid pointers or not
7780 unsigned long SgUntypedNameListDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7781 void SgUntypedNameListDeclaration_clearMemoryPool ( );
7782 void SgUntypedNameListDeclaration_extendMemoryPoolForFileIO ( );
7783 unsigned long SgUntypedNameListDeclaration_initializeStorageClassArray( SgUntypedNameListDeclarationStorageClass *storageArray );
7784 void SgUntypedNameListDeclaration_resetValidFreepointers( );
7785 unsigned long SgUntypedNameListDeclaration_getNumberOfLastValidPointer();
7786 
7787 
7788 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7789 
7790 #include <semaphore.h>
7791 // DQ (9/21/2005): Static variables supporting memory pools
7798 extern int SgUntypedUseStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7799 
7804 extern SgUntypedUseStatement* SgUntypedUseStatement_Current_Link; // = NULL;
7805 
7806 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7807 // This is was one of the things on the todo list (above).
7808 
7813 extern std::vector < unsigned char* > SgUntypedUseStatement_Memory_Block_List;
7814 /* */
7815 
7816 // DQ (4/6/2006): Newer code from Jochen
7817 // Methods to find the pointer to a global and local index
7818 SgUntypedUseStatement* SgUntypedUseStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7819 SgUntypedUseStatement* SgUntypedUseStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7820 
7821 // Methods for computing the total size of the memory pool. It actually returns the
7822 // size of the whole blocks allocated, no matter they contain valid pointers or not
7823 unsigned long SgUntypedUseStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7824 void SgUntypedUseStatement_clearMemoryPool ( );
7825 void SgUntypedUseStatement_extendMemoryPoolForFileIO ( );
7826 unsigned long SgUntypedUseStatement_initializeStorageClassArray( SgUntypedUseStatementStorageClass *storageArray );
7827 void SgUntypedUseStatement_resetValidFreepointers( );
7828 unsigned long SgUntypedUseStatement_getNumberOfLastValidPointer();
7829 
7830 
7831 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7832 
7833 #include <semaphore.h>
7834 // DQ (9/21/2005): Static variables supporting memory pools
7841 extern int SgUntypedImplicitDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7842 
7847 extern SgUntypedImplicitDeclaration* SgUntypedImplicitDeclaration_Current_Link; // = NULL;
7848 
7849 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7850 // This is was one of the things on the todo list (above).
7851 
7856 extern std::vector < unsigned char* > SgUntypedImplicitDeclaration_Memory_Block_List;
7857 /* */
7858 
7859 // DQ (4/6/2006): Newer code from Jochen
7860 // Methods to find the pointer to a global and local index
7861 SgUntypedImplicitDeclaration* SgUntypedImplicitDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7862 SgUntypedImplicitDeclaration* SgUntypedImplicitDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7863 
7864 // Methods for computing the total size of the memory pool. It actually returns the
7865 // size of the whole blocks allocated, no matter they contain valid pointers or not
7866 unsigned long SgUntypedImplicitDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7867 void SgUntypedImplicitDeclaration_clearMemoryPool ( );
7868 void SgUntypedImplicitDeclaration_extendMemoryPoolForFileIO ( );
7869 unsigned long SgUntypedImplicitDeclaration_initializeStorageClassArray( SgUntypedImplicitDeclarationStorageClass *storageArray );
7870 void SgUntypedImplicitDeclaration_resetValidFreepointers( );
7871 unsigned long SgUntypedImplicitDeclaration_getNumberOfLastValidPointer();
7872 
7873 
7874 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7875 
7876 #include <semaphore.h>
7877 // DQ (9/21/2005): Static variables supporting memory pools
7884 extern int SgUntypedVariableDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7885 
7890 extern SgUntypedVariableDeclaration* SgUntypedVariableDeclaration_Current_Link; // = NULL;
7891 
7892 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7893 // This is was one of the things on the todo list (above).
7894 
7899 extern std::vector < unsigned char* > SgUntypedVariableDeclaration_Memory_Block_List;
7900 /* */
7901 
7902 // DQ (4/6/2006): Newer code from Jochen
7903 // Methods to find the pointer to a global and local index
7904 SgUntypedVariableDeclaration* SgUntypedVariableDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7905 SgUntypedVariableDeclaration* SgUntypedVariableDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7906 
7907 // Methods for computing the total size of the memory pool. It actually returns the
7908 // size of the whole blocks allocated, no matter they contain valid pointers or not
7909 unsigned long SgUntypedVariableDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7910 void SgUntypedVariableDeclaration_clearMemoryPool ( );
7911 void SgUntypedVariableDeclaration_extendMemoryPoolForFileIO ( );
7912 unsigned long SgUntypedVariableDeclaration_initializeStorageClassArray( SgUntypedVariableDeclarationStorageClass *storageArray );
7913 void SgUntypedVariableDeclaration_resetValidFreepointers( );
7914 unsigned long SgUntypedVariableDeclaration_getNumberOfLastValidPointer();
7915 
7916 
7917 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7918 
7919 #include <semaphore.h>
7920 // DQ (9/21/2005): Static variables supporting memory pools
7927 extern int SgUntypedFunctionDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7928 
7933 extern SgUntypedFunctionDeclaration* SgUntypedFunctionDeclaration_Current_Link; // = NULL;
7934 
7935 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7936 // This is was one of the things on the todo list (above).
7937 
7942 extern std::vector < unsigned char* > SgUntypedFunctionDeclaration_Memory_Block_List;
7943 /* */
7944 
7945 // DQ (4/6/2006): Newer code from Jochen
7946 // Methods to find the pointer to a global and local index
7947 SgUntypedFunctionDeclaration* SgUntypedFunctionDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7948 SgUntypedFunctionDeclaration* SgUntypedFunctionDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7949 
7950 // Methods for computing the total size of the memory pool. It actually returns the
7951 // size of the whole blocks allocated, no matter they contain valid pointers or not
7952 unsigned long SgUntypedFunctionDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7953 void SgUntypedFunctionDeclaration_clearMemoryPool ( );
7954 void SgUntypedFunctionDeclaration_extendMemoryPoolForFileIO ( );
7955 unsigned long SgUntypedFunctionDeclaration_initializeStorageClassArray( SgUntypedFunctionDeclarationStorageClass *storageArray );
7956 void SgUntypedFunctionDeclaration_resetValidFreepointers( );
7957 unsigned long SgUntypedFunctionDeclaration_getNumberOfLastValidPointer();
7958 
7959 
7960 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
7961 
7962 #include <semaphore.h>
7963 // DQ (9/21/2005): Static variables supporting memory pools
7970 extern int SgUntypedProgramHeaderDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
7971 
7976 extern SgUntypedProgramHeaderDeclaration* SgUntypedProgramHeaderDeclaration_Current_Link; // = NULL;
7977 
7978 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
7979 // This is was one of the things on the todo list (above).
7980 
7985 extern std::vector < unsigned char* > SgUntypedProgramHeaderDeclaration_Memory_Block_List;
7986 /* */
7987 
7988 // DQ (4/6/2006): Newer code from Jochen
7989 // Methods to find the pointer to a global and local index
7990 SgUntypedProgramHeaderDeclaration* SgUntypedProgramHeaderDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
7991 SgUntypedProgramHeaderDeclaration* SgUntypedProgramHeaderDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
7992 
7993 // Methods for computing the total size of the memory pool. It actually returns the
7994 // size of the whole blocks allocated, no matter they contain valid pointers or not
7995 unsigned long SgUntypedProgramHeaderDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
7996 void SgUntypedProgramHeaderDeclaration_clearMemoryPool ( );
7997 void SgUntypedProgramHeaderDeclaration_extendMemoryPoolForFileIO ( );
7998 unsigned long SgUntypedProgramHeaderDeclaration_initializeStorageClassArray( SgUntypedProgramHeaderDeclarationStorageClass *storageArray );
7999 void SgUntypedProgramHeaderDeclaration_resetValidFreepointers( );
8000 unsigned long SgUntypedProgramHeaderDeclaration_getNumberOfLastValidPointer();
8001 
8002 
8003 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8004 
8005 #include <semaphore.h>
8006 // DQ (9/21/2005): Static variables supporting memory pools
8013 extern int SgUntypedSubroutineDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8014 
8019 extern SgUntypedSubroutineDeclaration* SgUntypedSubroutineDeclaration_Current_Link; // = NULL;
8020 
8021 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8022 // This is was one of the things on the todo list (above).
8023 
8028 extern std::vector < unsigned char* > SgUntypedSubroutineDeclaration_Memory_Block_List;
8029 /* */
8030 
8031 // DQ (4/6/2006): Newer code from Jochen
8032 // Methods to find the pointer to a global and local index
8033 SgUntypedSubroutineDeclaration* SgUntypedSubroutineDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8034 SgUntypedSubroutineDeclaration* SgUntypedSubroutineDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8035 
8036 // Methods for computing the total size of the memory pool. It actually returns the
8037 // size of the whole blocks allocated, no matter they contain valid pointers or not
8038 unsigned long SgUntypedSubroutineDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8039 void SgUntypedSubroutineDeclaration_clearMemoryPool ( );
8040 void SgUntypedSubroutineDeclaration_extendMemoryPoolForFileIO ( );
8041 unsigned long SgUntypedSubroutineDeclaration_initializeStorageClassArray( SgUntypedSubroutineDeclarationStorageClass *storageArray );
8042 void SgUntypedSubroutineDeclaration_resetValidFreepointers( );
8043 unsigned long SgUntypedSubroutineDeclaration_getNumberOfLastValidPointer();
8044 
8045 
8046 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8047 
8048 #include <semaphore.h>
8049 // DQ (9/21/2005): Static variables supporting memory pools
8056 extern int SgUntypedInterfaceDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8057 
8062 extern SgUntypedInterfaceDeclaration* SgUntypedInterfaceDeclaration_Current_Link; // = NULL;
8063 
8064 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8065 // This is was one of the things on the todo list (above).
8066 
8071 extern std::vector < unsigned char* > SgUntypedInterfaceDeclaration_Memory_Block_List;
8072 /* */
8073 
8074 // DQ (4/6/2006): Newer code from Jochen
8075 // Methods to find the pointer to a global and local index
8076 SgUntypedInterfaceDeclaration* SgUntypedInterfaceDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8077 SgUntypedInterfaceDeclaration* SgUntypedInterfaceDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8078 
8079 // Methods for computing the total size of the memory pool. It actually returns the
8080 // size of the whole blocks allocated, no matter they contain valid pointers or not
8081 unsigned long SgUntypedInterfaceDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8082 void SgUntypedInterfaceDeclaration_clearMemoryPool ( );
8083 void SgUntypedInterfaceDeclaration_extendMemoryPoolForFileIO ( );
8084 unsigned long SgUntypedInterfaceDeclaration_initializeStorageClassArray( SgUntypedInterfaceDeclarationStorageClass *storageArray );
8085 void SgUntypedInterfaceDeclaration_resetValidFreepointers( );
8086 unsigned long SgUntypedInterfaceDeclaration_getNumberOfLastValidPointer();
8087 
8088 
8089 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8090 
8091 #include <semaphore.h>
8092 // DQ (9/21/2005): Static variables supporting memory pools
8099 extern int SgUntypedModuleDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8100 
8105 extern SgUntypedModuleDeclaration* SgUntypedModuleDeclaration_Current_Link; // = NULL;
8106 
8107 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8108 // This is was one of the things on the todo list (above).
8109 
8114 extern std::vector < unsigned char* > SgUntypedModuleDeclaration_Memory_Block_List;
8115 /* */
8116 
8117 // DQ (4/6/2006): Newer code from Jochen
8118 // Methods to find the pointer to a global and local index
8119 SgUntypedModuleDeclaration* SgUntypedModuleDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8120 SgUntypedModuleDeclaration* SgUntypedModuleDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8121 
8122 // Methods for computing the total size of the memory pool. It actually returns the
8123 // size of the whole blocks allocated, no matter they contain valid pointers or not
8124 unsigned long SgUntypedModuleDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8125 void SgUntypedModuleDeclaration_clearMemoryPool ( );
8126 void SgUntypedModuleDeclaration_extendMemoryPoolForFileIO ( );
8127 unsigned long SgUntypedModuleDeclaration_initializeStorageClassArray( SgUntypedModuleDeclarationStorageClass *storageArray );
8128 void SgUntypedModuleDeclaration_resetValidFreepointers( );
8129 unsigned long SgUntypedModuleDeclaration_getNumberOfLastValidPointer();
8130 
8131 
8132 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8133 
8134 #include <semaphore.h>
8135 // DQ (9/21/2005): Static variables supporting memory pools
8142 extern int SgUntypedSubmoduleDeclaration_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8143 
8148 extern SgUntypedSubmoduleDeclaration* SgUntypedSubmoduleDeclaration_Current_Link; // = NULL;
8149 
8150 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8151 // This is was one of the things on the todo list (above).
8152 
8157 extern std::vector < unsigned char* > SgUntypedSubmoduleDeclaration_Memory_Block_List;
8158 /* */
8159 
8160 // DQ (4/6/2006): Newer code from Jochen
8161 // Methods to find the pointer to a global and local index
8162 SgUntypedSubmoduleDeclaration* SgUntypedSubmoduleDeclaration_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8163 SgUntypedSubmoduleDeclaration* SgUntypedSubmoduleDeclaration_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8164 
8165 // Methods for computing the total size of the memory pool. It actually returns the
8166 // size of the whole blocks allocated, no matter they contain valid pointers or not
8167 unsigned long SgUntypedSubmoduleDeclaration_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8168 void SgUntypedSubmoduleDeclaration_clearMemoryPool ( );
8169 void SgUntypedSubmoduleDeclaration_extendMemoryPoolForFileIO ( );
8170 unsigned long SgUntypedSubmoduleDeclaration_initializeStorageClassArray( SgUntypedSubmoduleDeclarationStorageClass *storageArray );
8171 void SgUntypedSubmoduleDeclaration_resetValidFreepointers( );
8172 unsigned long SgUntypedSubmoduleDeclaration_getNumberOfLastValidPointer();
8173 
8174 
8175 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8176 
8177 #include <semaphore.h>
8178 // DQ (9/21/2005): Static variables supporting memory pools
8185 extern int SgUntypedAssignmentStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8186 
8191 extern SgUntypedAssignmentStatement* SgUntypedAssignmentStatement_Current_Link; // = NULL;
8192 
8193 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8194 // This is was one of the things on the todo list (above).
8195 
8200 extern std::vector < unsigned char* > SgUntypedAssignmentStatement_Memory_Block_List;
8201 /* */
8202 
8203 // DQ (4/6/2006): Newer code from Jochen
8204 // Methods to find the pointer to a global and local index
8205 SgUntypedAssignmentStatement* SgUntypedAssignmentStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8206 SgUntypedAssignmentStatement* SgUntypedAssignmentStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8207 
8208 // Methods for computing the total size of the memory pool. It actually returns the
8209 // size of the whole blocks allocated, no matter they contain valid pointers or not
8210 unsigned long SgUntypedAssignmentStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8211 void SgUntypedAssignmentStatement_clearMemoryPool ( );
8212 void SgUntypedAssignmentStatement_extendMemoryPoolForFileIO ( );
8213 unsigned long SgUntypedAssignmentStatement_initializeStorageClassArray( SgUntypedAssignmentStatementStorageClass *storageArray );
8214 void SgUntypedAssignmentStatement_resetValidFreepointers( );
8215 unsigned long SgUntypedAssignmentStatement_getNumberOfLastValidPointer();
8216 
8217 
8218 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8219 
8220 #include <semaphore.h>
8221 // DQ (9/21/2005): Static variables supporting memory pools
8228 extern int SgUntypedFunctionCallStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8229 
8234 extern SgUntypedFunctionCallStatement* SgUntypedFunctionCallStatement_Current_Link; // = NULL;
8235 
8236 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8237 // This is was one of the things on the todo list (above).
8238 
8243 extern std::vector < unsigned char* > SgUntypedFunctionCallStatement_Memory_Block_List;
8244 /* */
8245 
8246 // DQ (4/6/2006): Newer code from Jochen
8247 // Methods to find the pointer to a global and local index
8248 SgUntypedFunctionCallStatement* SgUntypedFunctionCallStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8249 SgUntypedFunctionCallStatement* SgUntypedFunctionCallStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8250 
8251 // Methods for computing the total size of the memory pool. It actually returns the
8252 // size of the whole blocks allocated, no matter they contain valid pointers or not
8253 unsigned long SgUntypedFunctionCallStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8254 void SgUntypedFunctionCallStatement_clearMemoryPool ( );
8255 void SgUntypedFunctionCallStatement_extendMemoryPoolForFileIO ( );
8256 unsigned long SgUntypedFunctionCallStatement_initializeStorageClassArray( SgUntypedFunctionCallStatementStorageClass *storageArray );
8257 void SgUntypedFunctionCallStatement_resetValidFreepointers( );
8258 unsigned long SgUntypedFunctionCallStatement_getNumberOfLastValidPointer();
8259 
8260 
8261 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8262 
8263 #include <semaphore.h>
8264 // DQ (9/21/2005): Static variables supporting memory pools
8271 extern int SgUntypedBlockStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8272 
8277 extern SgUntypedBlockStatement* SgUntypedBlockStatement_Current_Link; // = NULL;
8278 
8279 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8280 // This is was one of the things on the todo list (above).
8281 
8286 extern std::vector < unsigned char* > SgUntypedBlockStatement_Memory_Block_List;
8287 /* */
8288 
8289 // DQ (4/6/2006): Newer code from Jochen
8290 // Methods to find the pointer to a global and local index
8291 SgUntypedBlockStatement* SgUntypedBlockStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8292 SgUntypedBlockStatement* SgUntypedBlockStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8293 
8294 // Methods for computing the total size of the memory pool. It actually returns the
8295 // size of the whole blocks allocated, no matter they contain valid pointers or not
8296 unsigned long SgUntypedBlockStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8297 void SgUntypedBlockStatement_clearMemoryPool ( );
8298 void SgUntypedBlockStatement_extendMemoryPoolForFileIO ( );
8299 unsigned long SgUntypedBlockStatement_initializeStorageClassArray( SgUntypedBlockStatementStorageClass *storageArray );
8300 void SgUntypedBlockStatement_resetValidFreepointers( );
8301 unsigned long SgUntypedBlockStatement_getNumberOfLastValidPointer();
8302 
8303 
8304 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8305 
8306 #include <semaphore.h>
8307 // DQ (9/21/2005): Static variables supporting memory pools
8314 extern int SgUntypedNamedStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8315 
8320 extern SgUntypedNamedStatement* SgUntypedNamedStatement_Current_Link; // = NULL;
8321 
8322 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8323 // This is was one of the things on the todo list (above).
8324 
8329 extern std::vector < unsigned char* > SgUntypedNamedStatement_Memory_Block_List;
8330 /* */
8331 
8332 // DQ (4/6/2006): Newer code from Jochen
8333 // Methods to find the pointer to a global and local index
8334 SgUntypedNamedStatement* SgUntypedNamedStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8335 SgUntypedNamedStatement* SgUntypedNamedStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8336 
8337 // Methods for computing the total size of the memory pool. It actually returns the
8338 // size of the whole blocks allocated, no matter they contain valid pointers or not
8339 unsigned long SgUntypedNamedStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8340 void SgUntypedNamedStatement_clearMemoryPool ( );
8341 void SgUntypedNamedStatement_extendMemoryPoolForFileIO ( );
8342 unsigned long SgUntypedNamedStatement_initializeStorageClassArray( SgUntypedNamedStatementStorageClass *storageArray );
8343 void SgUntypedNamedStatement_resetValidFreepointers( );
8344 unsigned long SgUntypedNamedStatement_getNumberOfLastValidPointer();
8345 
8346 
8347 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8348 
8349 #include <semaphore.h>
8350 // DQ (9/21/2005): Static variables supporting memory pools
8357 extern int SgUntypedExpressionStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8358 
8363 extern SgUntypedExpressionStatement* SgUntypedExpressionStatement_Current_Link; // = NULL;
8364 
8365 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8366 // This is was one of the things on the todo list (above).
8367 
8372 extern std::vector < unsigned char* > SgUntypedExpressionStatement_Memory_Block_List;
8373 /* */
8374 
8375 // DQ (4/6/2006): Newer code from Jochen
8376 // Methods to find the pointer to a global and local index
8377 SgUntypedExpressionStatement* SgUntypedExpressionStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8378 SgUntypedExpressionStatement* SgUntypedExpressionStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8379 
8380 // Methods for computing the total size of the memory pool. It actually returns the
8381 // size of the whole blocks allocated, no matter they contain valid pointers or not
8382 unsigned long SgUntypedExpressionStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8383 void SgUntypedExpressionStatement_clearMemoryPool ( );
8384 void SgUntypedExpressionStatement_extendMemoryPoolForFileIO ( );
8385 unsigned long SgUntypedExpressionStatement_initializeStorageClassArray( SgUntypedExpressionStatementStorageClass *storageArray );
8386 void SgUntypedExpressionStatement_resetValidFreepointers( );
8387 unsigned long SgUntypedExpressionStatement_getNumberOfLastValidPointer();
8388 
8389 
8390 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8391 
8392 #include <semaphore.h>
8393 // DQ (9/21/2005): Static variables supporting memory pools
8400 extern int SgUntypedOtherStatement_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8401 
8406 extern SgUntypedOtherStatement* SgUntypedOtherStatement_Current_Link; // = NULL;
8407 
8408 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8409 // This is was one of the things on the todo list (above).
8410 
8415 extern std::vector < unsigned char* > SgUntypedOtherStatement_Memory_Block_List;
8416 /* */
8417 
8418 // DQ (4/6/2006): Newer code from Jochen
8419 // Methods to find the pointer to a global and local index
8420 SgUntypedOtherStatement* SgUntypedOtherStatement_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8421 SgUntypedOtherStatement* SgUntypedOtherStatement_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8422 
8423 // Methods for computing the total size of the memory pool. It actually returns the
8424 // size of the whole blocks allocated, no matter they contain valid pointers or not
8425 unsigned long SgUntypedOtherStatement_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8426 void SgUntypedOtherStatement_clearMemoryPool ( );
8427 void SgUntypedOtherStatement_extendMemoryPoolForFileIO ( );
8428 unsigned long SgUntypedOtherStatement_initializeStorageClassArray( SgUntypedOtherStatementStorageClass *storageArray );
8429 void SgUntypedOtherStatement_resetValidFreepointers( );
8430 unsigned long SgUntypedOtherStatement_getNumberOfLastValidPointer();
8431 
8432 
8433 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8434 
8435 #include <semaphore.h>
8436 // DQ (9/21/2005): Static variables supporting memory pools
8443 extern int SgUntypedScope_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8444 
8449 extern SgUntypedScope* SgUntypedScope_Current_Link; // = NULL;
8450 
8451 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8452 // This is was one of the things on the todo list (above).
8453 
8458 extern std::vector < unsigned char* > SgUntypedScope_Memory_Block_List;
8459 /* */
8460 
8461 // DQ (4/6/2006): Newer code from Jochen
8462 // Methods to find the pointer to a global and local index
8463 SgUntypedScope* SgUntypedScope_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8464 SgUntypedScope* SgUntypedScope_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8465 
8466 // Methods for computing the total size of the memory pool. It actually returns the
8467 // size of the whole blocks allocated, no matter they contain valid pointers or not
8468 unsigned long SgUntypedScope_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8469 void SgUntypedScope_clearMemoryPool ( );
8470 void SgUntypedScope_extendMemoryPoolForFileIO ( );
8471 unsigned long SgUntypedScope_initializeStorageClassArray( SgUntypedScopeStorageClass *storageArray );
8472 void SgUntypedScope_resetValidFreepointers( );
8473 unsigned long SgUntypedScope_getNumberOfLastValidPointer();
8474 
8475 
8476 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8477 
8478 #include <semaphore.h>
8479 // DQ (9/21/2005): Static variables supporting memory pools
8486 extern int SgUntypedFunctionScope_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8487 
8492 extern SgUntypedFunctionScope* SgUntypedFunctionScope_Current_Link; // = NULL;
8493 
8494 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8495 // This is was one of the things on the todo list (above).
8496 
8501 extern std::vector < unsigned char* > SgUntypedFunctionScope_Memory_Block_List;
8502 /* */
8503 
8504 // DQ (4/6/2006): Newer code from Jochen
8505 // Methods to find the pointer to a global and local index
8506 SgUntypedFunctionScope* SgUntypedFunctionScope_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8507 SgUntypedFunctionScope* SgUntypedFunctionScope_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8508 
8509 // Methods for computing the total size of the memory pool. It actually returns the
8510 // size of the whole blocks allocated, no matter they contain valid pointers or not
8511 unsigned long SgUntypedFunctionScope_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8512 void SgUntypedFunctionScope_clearMemoryPool ( );
8513 void SgUntypedFunctionScope_extendMemoryPoolForFileIO ( );
8514 unsigned long SgUntypedFunctionScope_initializeStorageClassArray( SgUntypedFunctionScopeStorageClass *storageArray );
8515 void SgUntypedFunctionScope_resetValidFreepointers( );
8516 unsigned long SgUntypedFunctionScope_getNumberOfLastValidPointer();
8517 
8518 
8519 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8520 
8521 #include <semaphore.h>
8522 // DQ (9/21/2005): Static variables supporting memory pools
8529 extern int SgUntypedModuleScope_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8530 
8535 extern SgUntypedModuleScope* SgUntypedModuleScope_Current_Link; // = NULL;
8536 
8537 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8538 // This is was one of the things on the todo list (above).
8539 
8544 extern std::vector < unsigned char* > SgUntypedModuleScope_Memory_Block_List;
8545 /* */
8546 
8547 // DQ (4/6/2006): Newer code from Jochen
8548 // Methods to find the pointer to a global and local index
8549 SgUntypedModuleScope* SgUntypedModuleScope_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8550 SgUntypedModuleScope* SgUntypedModuleScope_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8551 
8552 // Methods for computing the total size of the memory pool. It actually returns the
8553 // size of the whole blocks allocated, no matter they contain valid pointers or not
8554 unsigned long SgUntypedModuleScope_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8555 void SgUntypedModuleScope_clearMemoryPool ( );
8556 void SgUntypedModuleScope_extendMemoryPoolForFileIO ( );
8557 unsigned long SgUntypedModuleScope_initializeStorageClassArray( SgUntypedModuleScopeStorageClass *storageArray );
8558 void SgUntypedModuleScope_resetValidFreepointers( );
8559 unsigned long SgUntypedModuleScope_getNumberOfLastValidPointer();
8560 
8561 
8562 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8563 
8564 #include <semaphore.h>
8565 // DQ (9/21/2005): Static variables supporting memory pools
8572 extern int SgUntypedGlobalScope_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8573 
8578 extern SgUntypedGlobalScope* SgUntypedGlobalScope_Current_Link; // = NULL;
8579 
8580 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8581 // This is was one of the things on the todo list (above).
8582 
8587 extern std::vector < unsigned char* > SgUntypedGlobalScope_Memory_Block_List;
8588 /* */
8589 
8590 // DQ (4/6/2006): Newer code from Jochen
8591 // Methods to find the pointer to a global and local index
8592 SgUntypedGlobalScope* SgUntypedGlobalScope_getPointerFromGlobalIndex ( unsigned long globalIndex ) ;
8593 SgUntypedGlobalScope* SgUntypedGlobalScope_getPointerFromGlobalIndex ( AstSpecificDataManagingClass* astInPool, unsigned long globalIndex ) ;
8594 
8595 // Methods for computing the total size of the memory pool. It actually returns the
8596 // size of the whole blocks allocated, no matter they contain valid pointers or not
8597 unsigned long SgUntypedGlobalScope_getNumberOfValidNodesAndSetGlobalIndexInFreepointer( unsigned long );
8598 void SgUntypedGlobalScope_clearMemoryPool ( );
8599 void SgUntypedGlobalScope_extendMemoryPoolForFileIO ( );
8600 unsigned long SgUntypedGlobalScope_initializeStorageClassArray( SgUntypedGlobalScopeStorageClass *storageArray );
8601 void SgUntypedGlobalScope_resetValidFreepointers( );
8602 unsigned long SgUntypedGlobalScope_getNumberOfLastValidPointer();
8603 
8604 
8605 /* #line 1 "/export/tmp.rose-mgr/applications/jenkins/data/1.0.0/jobs/release-ROSE-docs/workspace/src/ROSETTA/Grammar/grammarMemoryPoolSupport.macro" */
8606 
8607 #include <semaphore.h>
8608 // DQ (9/21/2005): Static variables supporting memory pools
8615 extern int SgUntypedName_CLASS_ALLOCATION_POOL_SIZE; // = DEFAULT_CLASS_ALLOCATION_POOL_SIZE;
8616 
8621 extern SgUntypedName* SgUntypedName_Current_Link; // = NULL;
8622 
8623 // DQ (12/15/2005): This is Jochen's implementation of the memory allocation pools.
8624 // This is was one of the things on the todo list (above).
8625 
8630 extern std::vector < unsigned char* > SgUntypedName_Memory_Block_List;
8631 /* */
8632 
8633 // DQ (4/6/2006): Newer code from Jochen
8634 // Methods to find the pointer to a global and local index