Line data Source code
1 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
2 : // tps : need to include sage3basic.h -- took it out from the header file because precompiled headers cannot be included in header files
3 : #include "sage3basic.h" // file_IO
4 : #include "rosedefs.h"
5 : #include "Cxx_GrammarMemoryPoolSupport.h"
6 : #include <fstream>
7 : #include "AST_FILE_IO.h"
8 : #include "StorageClasses.h"
9 : #include <sstream>
10 : #include <string>
11 :
12 : using namespace std;
13 :
14 : AstData*
15 : AST_FILE_IO :: actualRebuildAst;
16 :
17 : std::vector<AstData*>
18 : AST_FILE_IO :: vectorOfASTs;
19 :
20 : unsigned long
21 : AST_FILE_IO :: listOfMemoryPoolSizes [ totalNumberOfIRNodes + 1] ;
22 :
23 : bool
24 : AST_FILE_IO :: freepointersOfCurrentAstAreSetToGlobalIndices;
25 :
26 : std::map<std::string, AST_FILE_IO::CONSTRUCTOR >
27 : AST_FILE_IO::registeredAttributes;
28 :
29 :
30 : /* JH (10/25/2005): Static method that computes the memory pool sizes and stores them incrementally
31 : in listOfAccumulatedPoolSizes at position [ V_$CLASSNAME + 1 ]. Reason for this strange issue; no global
32 : index must be 0, since we want to store NULL pointers as 0 ( means, we will not manipulate them ).
33 : Therefore, we introduce 'listOfAccumulatedPoolSizes [ 0 ] = 1', in order to calculate the index of an
34 : node by computing the index in its memory pool and then adding the getAccumulated sizes of the previous
35 : memory pools, already stored in listOfAccumulatedPoolSizes [ V_$CLASSNAME ].
36 : */
37 :
38 : #define DEBUG_AstFileIO_startUp 0
39 :
40 : void
41 5 : AST_FILE_IO :: startUp( SgProject* root )
42 : {
43 : #if DEBUG_AstFileIO_startUp
44 : std::cout << "AST_FILE_IO::startUp" << std::endl;
45 : #endif
46 : /* Our array containing the total memory pool sizes starts at startingIndex. This is the first multiple of 100
47 : that is greater than the indices used internally. We sort the the memory pool size at
48 : position [ V_$CLASSNAME + 1 ]. Concurrently, we allocate the appropriate STORAGE_class_list arrays.
49 : If the corresponding memory pool is empty, we set the pointer to NULL!
50 : */
51 : // DQ (4/22/2006): Added timer information for AST File I/O
52 10 : TimingPerformance timer ("AST_FILE_IO::startUp():");
53 :
54 5 : assert ( vectorOfASTs.empty() == true );
55 5 : assert ( root != NULL );
56 :
57 : #if FILE_IO_EXTRA_CHECK
58 5 : {
59 : // DQ (4/22/2006): Added timer information for AST File I/O
60 5 : TimingPerformance nested_timer ("AST_FILE_IO::startUp() FILE_IO_EXTRA_CHECK:");
61 :
62 5 : if ( SgProject::get_verbose() > 0 )
63 0 : std::cout << "Starting check, that all IRNodes are in the memory pools ... " << std::flush;
64 : #if FILE_IO_MEMORY_POOL_CHECK
65 : // AST_FileIO::MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal;
66 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal;
67 : memoryCheckingTraversal.traverseMemoryPool();
68 : #endif
69 :
70 5 : if ( SgProject::get_verbose() > 0 )
71 5 : std::cout << " done ! " << std::endl;
72 : }
73 : #endif
74 :
75 : // JH: the global index counting starts at index 1, because we want to store NULL pointers as 0!
76 5 : unsigned long globalIndexCounter = 1;
77 :
78 5 : listOfMemoryPoolSizes [ 0 ] = globalIndexCounter;
79 5 : listOfMemoryPoolSizes [ 1 ] = globalIndexCounter;
80 5 : globalIndexCounter = SgAccessModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
81 5 : listOfMemoryPoolSizes [ 2 ] = globalIndexCounter;
82 5 : globalIndexCounter = SgActualArgumentExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
83 5 : listOfMemoryPoolSizes [ 3 ] = globalIndexCounter;
84 5 : globalIndexCounter = SgAddOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
85 5 : listOfMemoryPoolSizes [ 4 ] = globalIndexCounter;
86 5 : globalIndexCounter = SgAddressOfOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
87 5 : listOfMemoryPoolSizes [ 5 ] = globalIndexCounter;
88 5 : globalIndexCounter = SgAggregateInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
89 5 : listOfMemoryPoolSizes [ 6 ] = globalIndexCounter;
90 5 : globalIndexCounter = SgAliasSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
91 5 : listOfMemoryPoolSizes [ 7 ] = globalIndexCounter;
92 5 : globalIndexCounter = SgAllocateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
93 5 : listOfMemoryPoolSizes [ 8 ] = globalIndexCounter;
94 5 : globalIndexCounter = SgAndAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
95 5 : listOfMemoryPoolSizes [ 9 ] = globalIndexCounter;
96 5 : globalIndexCounter = SgAndOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
97 5 : listOfMemoryPoolSizes [ 10 ] = globalIndexCounter;
98 5 : globalIndexCounter = SgArithmeticIfStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
99 5 : listOfMemoryPoolSizes [ 11 ] = globalIndexCounter;
100 5 : globalIndexCounter = SgArrayType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
101 5 : listOfMemoryPoolSizes [ 12 ] = globalIndexCounter;
102 5 : globalIndexCounter = SgArrowExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
103 5 : listOfMemoryPoolSizes [ 13 ] = globalIndexCounter;
104 5 : globalIndexCounter = SgArrowStarOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
105 5 : listOfMemoryPoolSizes [ 14 ] = globalIndexCounter;
106 5 : globalIndexCounter = SgAsmOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
107 5 : listOfMemoryPoolSizes [ 15 ] = globalIndexCounter;
108 5 : globalIndexCounter = SgAsmStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
109 5 : listOfMemoryPoolSizes [ 16 ] = globalIndexCounter;
110 5 : globalIndexCounter = SgAssertStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
111 5 : listOfMemoryPoolSizes [ 17 ] = globalIndexCounter;
112 5 : globalIndexCounter = SgAssignInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
113 5 : listOfMemoryPoolSizes [ 18 ] = globalIndexCounter;
114 5 : globalIndexCounter = SgAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
115 5 : listOfMemoryPoolSizes [ 19 ] = globalIndexCounter;
116 5 : globalIndexCounter = SgAssignStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
117 5 : listOfMemoryPoolSizes [ 20 ] = globalIndexCounter;
118 5 : globalIndexCounter = SgAssignedGotoStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
119 5 : listOfMemoryPoolSizes [ 21 ] = globalIndexCounter;
120 5 : globalIndexCounter = SgAssociateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
121 5 : listOfMemoryPoolSizes [ 22 ] = globalIndexCounter;
122 5 : globalIndexCounter = SgAsteriskShapeExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
123 5 : listOfMemoryPoolSizes [ 23 ] = globalIndexCounter;
124 5 : globalIndexCounter = SgAttribute::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
125 5 : listOfMemoryPoolSizes [ 24 ] = globalIndexCounter;
126 5 : globalIndexCounter = SgAttributeSpecificationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
127 5 : listOfMemoryPoolSizes [ 25 ] = globalIndexCounter;
128 5 : globalIndexCounter = SgAutoType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
129 5 : listOfMemoryPoolSizes [ 26 ] = globalIndexCounter;
130 5 : globalIndexCounter = SgAwaitExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
131 5 : listOfMemoryPoolSizes [ 27 ] = globalIndexCounter;
132 5 : globalIndexCounter = SgBackspaceStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
133 5 : listOfMemoryPoolSizes [ 28 ] = globalIndexCounter;
134 5 : globalIndexCounter = SgBaseClass::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
135 5 : listOfMemoryPoolSizes [ 29 ] = globalIndexCounter;
136 5 : globalIndexCounter = SgExpBaseClass::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
137 5 : listOfMemoryPoolSizes [ 30 ] = globalIndexCounter;
138 5 : globalIndexCounter = SgBaseClassModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
139 5 : listOfMemoryPoolSizes [ 31 ] = globalIndexCounter;
140 5 : globalIndexCounter = SgBasicBlock::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
141 5 : listOfMemoryPoolSizes [ 32 ] = globalIndexCounter;
142 5 : globalIndexCounter = SgBidirectionalGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
143 5 : listOfMemoryPoolSizes [ 33 ] = globalIndexCounter;
144 5 : listOfMemoryPoolSizes [ 34 ] = globalIndexCounter;
145 5 : globalIndexCounter = SgBinaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
146 5 : listOfMemoryPoolSizes [ 35 ] = globalIndexCounter;
147 5 : globalIndexCounter = SgBitAndOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
148 5 : listOfMemoryPoolSizes [ 36 ] = globalIndexCounter;
149 5 : globalIndexCounter = SgBitAttribute::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
150 5 : listOfMemoryPoolSizes [ 37 ] = globalIndexCounter;
151 5 : globalIndexCounter = SgBitComplementOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
152 5 : listOfMemoryPoolSizes [ 38 ] = globalIndexCounter;
153 5 : globalIndexCounter = SgBitEqvOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
154 5 : listOfMemoryPoolSizes [ 39 ] = globalIndexCounter;
155 5 : globalIndexCounter = SgBitOrOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
156 5 : listOfMemoryPoolSizes [ 40 ] = globalIndexCounter;
157 5 : globalIndexCounter = SgBitXorOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
158 5 : listOfMemoryPoolSizes [ 41 ] = globalIndexCounter;
159 5 : globalIndexCounter = SgBlockDataStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
160 5 : listOfMemoryPoolSizes [ 42 ] = globalIndexCounter;
161 5 : globalIndexCounter = SgBoolValExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
162 5 : listOfMemoryPoolSizes [ 43 ] = globalIndexCounter;
163 5 : globalIndexCounter = SgBreakStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
164 5 : listOfMemoryPoolSizes [ 44 ] = globalIndexCounter;
165 5 : globalIndexCounter = SgBracedInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
166 5 : listOfMemoryPoolSizes [ 45 ] = globalIndexCounter;
167 5 : globalIndexCounter = SgC_PreprocessorDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
168 5 : listOfMemoryPoolSizes [ 46 ] = globalIndexCounter;
169 5 : globalIndexCounter = SgCaseOptionStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
170 5 : listOfMemoryPoolSizes [ 47 ] = globalIndexCounter;
171 5 : globalIndexCounter = SgCastExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
172 5 : listOfMemoryPoolSizes [ 48 ] = globalIndexCounter;
173 5 : globalIndexCounter = SgCatchOptionStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
174 5 : listOfMemoryPoolSizes [ 49 ] = globalIndexCounter;
175 5 : globalIndexCounter = SgCatchStatementSeq::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
176 5 : listOfMemoryPoolSizes [ 50 ] = globalIndexCounter;
177 5 : globalIndexCounter = SgCharVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
178 5 : listOfMemoryPoolSizes [ 51 ] = globalIndexCounter;
179 5 : globalIndexCounter = SgChar16Val::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
180 5 : listOfMemoryPoolSizes [ 52 ] = globalIndexCounter;
181 5 : globalIndexCounter = SgChar32Val::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
182 5 : listOfMemoryPoolSizes [ 53 ] = globalIndexCounter;
183 5 : globalIndexCounter = SgChooseExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
184 5 : listOfMemoryPoolSizes [ 54 ] = globalIndexCounter;
185 5 : globalIndexCounter = SgClassDecl_attr::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
186 5 : listOfMemoryPoolSizes [ 55 ] = globalIndexCounter;
187 5 : globalIndexCounter = SgClassDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
188 5 : listOfMemoryPoolSizes [ 56 ] = globalIndexCounter;
189 5 : globalIndexCounter = SgClassDefinition::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
190 5 : listOfMemoryPoolSizes [ 57 ] = globalIndexCounter;
191 5 : globalIndexCounter = SgClassNameRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
192 5 : listOfMemoryPoolSizes [ 58 ] = globalIndexCounter;
193 5 : globalIndexCounter = SgClassSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
194 5 : listOfMemoryPoolSizes [ 59 ] = globalIndexCounter;
195 5 : globalIndexCounter = SgClassType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
196 5 : listOfMemoryPoolSizes [ 60 ] = globalIndexCounter;
197 5 : globalIndexCounter = SgClinkageDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
198 5 : listOfMemoryPoolSizes [ 61 ] = globalIndexCounter;
199 5 : globalIndexCounter = SgClinkageEndStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
200 5 : listOfMemoryPoolSizes [ 62 ] = globalIndexCounter;
201 5 : globalIndexCounter = SgClinkageStartStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
202 5 : listOfMemoryPoolSizes [ 63 ] = globalIndexCounter;
203 5 : globalIndexCounter = SgCloseStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
204 5 : listOfMemoryPoolSizes [ 64 ] = globalIndexCounter;
205 5 : globalIndexCounter = SgColonShapeExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
206 5 : listOfMemoryPoolSizes [ 65 ] = globalIndexCounter;
207 5 : globalIndexCounter = SgCommaOpExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
208 5 : listOfMemoryPoolSizes [ 66 ] = globalIndexCounter;
209 5 : globalIndexCounter = SgCommonBlock::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
210 5 : listOfMemoryPoolSizes [ 67 ] = globalIndexCounter;
211 5 : globalIndexCounter = SgCommonBlockObject::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
212 5 : listOfMemoryPoolSizes [ 68 ] = globalIndexCounter;
213 5 : globalIndexCounter = SgCommonSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
214 5 : listOfMemoryPoolSizes [ 69 ] = globalIndexCounter;
215 5 : globalIndexCounter = SgComplexVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
216 5 : listOfMemoryPoolSizes [ 70 ] = globalIndexCounter;
217 5 : globalIndexCounter = SgComprehension::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
218 5 : listOfMemoryPoolSizes [ 71 ] = globalIndexCounter;
219 5 : listOfMemoryPoolSizes [ 72 ] = globalIndexCounter;
220 5 : globalIndexCounter = SgCompoundAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
221 5 : listOfMemoryPoolSizes [ 73 ] = globalIndexCounter;
222 5 : globalIndexCounter = SgCompoundInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
223 5 : listOfMemoryPoolSizes [ 74 ] = globalIndexCounter;
224 5 : globalIndexCounter = SgCompoundLiteralExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
225 5 : listOfMemoryPoolSizes [ 75 ] = globalIndexCounter;
226 5 : globalIndexCounter = SgComputedGotoStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
227 5 : listOfMemoryPoolSizes [ 76 ] = globalIndexCounter;
228 5 : globalIndexCounter = SgConcatenationOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
229 5 : listOfMemoryPoolSizes [ 77 ] = globalIndexCounter;
230 5 : globalIndexCounter = SgConditionalExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
231 5 : listOfMemoryPoolSizes [ 78 ] = globalIndexCounter;
232 5 : globalIndexCounter = SgConjugateOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
233 5 : listOfMemoryPoolSizes [ 79 ] = globalIndexCounter;
234 5 : globalIndexCounter = SgConstVolatileModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
235 5 : listOfMemoryPoolSizes [ 80 ] = globalIndexCounter;
236 5 : globalIndexCounter = SgConstructorInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
237 5 : listOfMemoryPoolSizes [ 81 ] = globalIndexCounter;
238 5 : globalIndexCounter = SgContainsStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
239 5 : listOfMemoryPoolSizes [ 82 ] = globalIndexCounter;
240 5 : globalIndexCounter = SgContinueStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
241 5 : listOfMemoryPoolSizes [ 83 ] = globalIndexCounter;
242 5 : globalIndexCounter = SgCtorInitializerList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
243 5 : listOfMemoryPoolSizes [ 84 ] = globalIndexCounter;
244 5 : globalIndexCounter = SgDataStatementGroup::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
245 5 : listOfMemoryPoolSizes [ 85 ] = globalIndexCounter;
246 5 : globalIndexCounter = SgDataStatementObject::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
247 5 : listOfMemoryPoolSizes [ 86 ] = globalIndexCounter;
248 5 : globalIndexCounter = SgDataStatementValue::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
249 5 : listOfMemoryPoolSizes [ 87 ] = globalIndexCounter;
250 5 : globalIndexCounter = SgDeadIfDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
251 5 : listOfMemoryPoolSizes [ 88 ] = globalIndexCounter;
252 5 : globalIndexCounter = SgDeallocateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
253 5 : listOfMemoryPoolSizes [ 89 ] = globalIndexCounter;
254 5 : globalIndexCounter = SgDeclarationModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
255 5 : listOfMemoryPoolSizes [ 90 ] = globalIndexCounter;
256 5 : globalIndexCounter = SgDeclarationScope::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
257 5 : listOfMemoryPoolSizes [ 91 ] = globalIndexCounter;
258 5 : globalIndexCounter = SgDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
259 5 : listOfMemoryPoolSizes [ 92 ] = globalIndexCounter;
260 5 : globalIndexCounter = SgDeclType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
261 5 : listOfMemoryPoolSizes [ 93 ] = globalIndexCounter;
262 5 : globalIndexCounter = SgDefaultOptionStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
263 5 : listOfMemoryPoolSizes [ 94 ] = globalIndexCounter;
264 5 : globalIndexCounter = SgDefaultSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
265 5 : listOfMemoryPoolSizes [ 95 ] = globalIndexCounter;
266 5 : globalIndexCounter = SgDefineDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
267 5 : listOfMemoryPoolSizes [ 96 ] = globalIndexCounter;
268 5 : globalIndexCounter = SgDeleteExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
269 5 : listOfMemoryPoolSizes [ 97 ] = globalIndexCounter;
270 5 : globalIndexCounter = SgDerivedTypeStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
271 5 : listOfMemoryPoolSizes [ 98 ] = globalIndexCounter;
272 5 : globalIndexCounter = SgDesignatedInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
273 5 : listOfMemoryPoolSizes [ 99 ] = globalIndexCounter;
274 5 : globalIndexCounter = SgDictionaryComprehension::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
275 5 : listOfMemoryPoolSizes [ 100 ] = globalIndexCounter;
276 5 : globalIndexCounter = SgDictionaryExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
277 5 : listOfMemoryPoolSizes [ 101 ] = globalIndexCounter;
278 5 : globalIndexCounter = SgDimensionObject::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
279 5 : listOfMemoryPoolSizes [ 102 ] = globalIndexCounter;
280 5 : listOfMemoryPoolSizes [ 103 ] = globalIndexCounter;
281 5 : globalIndexCounter = SgDirectedGraphEdge::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
282 5 : listOfMemoryPoolSizes [ 104 ] = globalIndexCounter;
283 5 : listOfMemoryPoolSizes [ 105 ] = globalIndexCounter;
284 5 : globalIndexCounter = SgDirectory::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
285 5 : listOfMemoryPoolSizes [ 106 ] = globalIndexCounter;
286 5 : globalIndexCounter = SgDirectoryList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
287 5 : listOfMemoryPoolSizes [ 107 ] = globalIndexCounter;
288 5 : globalIndexCounter = SgDivAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
289 5 : listOfMemoryPoolSizes [ 108 ] = globalIndexCounter;
290 5 : globalIndexCounter = SgDivideOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
291 5 : listOfMemoryPoolSizes [ 109 ] = globalIndexCounter;
292 5 : globalIndexCounter = SgDoWhileStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
293 5 : listOfMemoryPoolSizes [ 110 ] = globalIndexCounter;
294 5 : globalIndexCounter = SgDotExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
295 5 : listOfMemoryPoolSizes [ 111 ] = globalIndexCounter;
296 5 : globalIndexCounter = SgDotStarOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
297 5 : listOfMemoryPoolSizes [ 112 ] = globalIndexCounter;
298 5 : globalIndexCounter = SgDoubleVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
299 5 : listOfMemoryPoolSizes [ 113 ] = globalIndexCounter;
300 5 : globalIndexCounter = SgElaboratedTypeModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
301 5 : listOfMemoryPoolSizes [ 114 ] = globalIndexCounter;
302 5 : globalIndexCounter = SgElementwiseOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
303 5 : listOfMemoryPoolSizes [ 115 ] = globalIndexCounter;
304 5 : globalIndexCounter = SgElementwiseAddOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
305 5 : listOfMemoryPoolSizes [ 116 ] = globalIndexCounter;
306 5 : globalIndexCounter = SgElementwiseDivideOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
307 5 : listOfMemoryPoolSizes [ 117 ] = globalIndexCounter;
308 5 : globalIndexCounter = SgElementwiseLeftDivideOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
309 5 : listOfMemoryPoolSizes [ 118 ] = globalIndexCounter;
310 5 : globalIndexCounter = SgElementwiseMultiplyOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
311 5 : listOfMemoryPoolSizes [ 119 ] = globalIndexCounter;
312 5 : globalIndexCounter = SgElementwisePowerOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
313 5 : listOfMemoryPoolSizes [ 120 ] = globalIndexCounter;
314 5 : globalIndexCounter = SgElementwiseSubtractOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
315 5 : listOfMemoryPoolSizes [ 121 ] = globalIndexCounter;
316 5 : globalIndexCounter = SgElseDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
317 5 : listOfMemoryPoolSizes [ 122 ] = globalIndexCounter;
318 5 : globalIndexCounter = SgElseWhereStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
319 5 : listOfMemoryPoolSizes [ 123 ] = globalIndexCounter;
320 5 : globalIndexCounter = SgElseifDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
321 5 : listOfMemoryPoolSizes [ 124 ] = globalIndexCounter;
322 5 : globalIndexCounter = SgEmptyDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
323 5 : listOfMemoryPoolSizes [ 125 ] = globalIndexCounter;
324 5 : globalIndexCounter = SgEmptyDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
325 5 : listOfMemoryPoolSizes [ 126 ] = globalIndexCounter;
326 5 : globalIndexCounter = SgEndfileStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
327 5 : listOfMemoryPoolSizes [ 127 ] = globalIndexCounter;
328 5 : globalIndexCounter = SgEndifDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
329 5 : listOfMemoryPoolSizes [ 128 ] = globalIndexCounter;
330 5 : globalIndexCounter = SgEntryStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
331 5 : listOfMemoryPoolSizes [ 129 ] = globalIndexCounter;
332 5 : globalIndexCounter = SgEnumDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
333 5 : listOfMemoryPoolSizes [ 130 ] = globalIndexCounter;
334 5 : globalIndexCounter = SgEnumFieldSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
335 5 : listOfMemoryPoolSizes [ 131 ] = globalIndexCounter;
336 5 : globalIndexCounter = SgEnumSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
337 5 : listOfMemoryPoolSizes [ 132 ] = globalIndexCounter;
338 5 : globalIndexCounter = SgEnumType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
339 5 : listOfMemoryPoolSizes [ 133 ] = globalIndexCounter;
340 5 : globalIndexCounter = SgEnumVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
341 5 : listOfMemoryPoolSizes [ 134 ] = globalIndexCounter;
342 5 : globalIndexCounter = SgEqualityOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
343 5 : listOfMemoryPoolSizes [ 135 ] = globalIndexCounter;
344 5 : globalIndexCounter = SgEquivalenceStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
345 5 : listOfMemoryPoolSizes [ 136 ] = globalIndexCounter;
346 5 : globalIndexCounter = SgErrorDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
347 5 : listOfMemoryPoolSizes [ 137 ] = globalIndexCounter;
348 5 : globalIndexCounter = SgExecStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
349 5 : listOfMemoryPoolSizes [ 138 ] = globalIndexCounter;
350 5 : globalIndexCounter = SgExponentiationOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
351 5 : listOfMemoryPoolSizes [ 139 ] = globalIndexCounter;
352 5 : globalIndexCounter = SgExponentiationAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
353 5 : listOfMemoryPoolSizes [ 140 ] = globalIndexCounter;
354 5 : globalIndexCounter = SgExprListExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
355 5 : listOfMemoryPoolSizes [ 141 ] = globalIndexCounter;
356 5 : globalIndexCounter = SgExprStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
357 5 : listOfMemoryPoolSizes [ 142 ] = globalIndexCounter;
358 5 : globalIndexCounter = SgExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
359 5 : listOfMemoryPoolSizes [ 143 ] = globalIndexCounter;
360 5 : globalIndexCounter = SgExpressionRoot::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
361 5 : listOfMemoryPoolSizes [ 144 ] = globalIndexCounter;
362 5 : globalIndexCounter = SgFile::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
363 5 : listOfMemoryPoolSizes [ 145 ] = globalIndexCounter;
364 5 : globalIndexCounter = SgFileList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
365 5 : listOfMemoryPoolSizes [ 146 ] = globalIndexCounter;
366 5 : globalIndexCounter = SgFloatVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
367 5 : listOfMemoryPoolSizes [ 147 ] = globalIndexCounter;
368 5 : globalIndexCounter = SgFloat128Val::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
369 5 : listOfMemoryPoolSizes [ 148 ] = globalIndexCounter;
370 5 : globalIndexCounter = SgFloat80Val::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
371 5 : listOfMemoryPoolSizes [ 149 ] = globalIndexCounter;
372 5 : globalIndexCounter = SgFoldExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
373 5 : listOfMemoryPoolSizes [ 150 ] = globalIndexCounter;
374 5 : globalIndexCounter = SgFlushStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
375 5 : listOfMemoryPoolSizes [ 151 ] = globalIndexCounter;
376 5 : globalIndexCounter = SgForAllStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
377 5 : listOfMemoryPoolSizes [ 152 ] = globalIndexCounter;
378 5 : globalIndexCounter = SgForInitStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
379 5 : listOfMemoryPoolSizes [ 153 ] = globalIndexCounter;
380 5 : globalIndexCounter = SgForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
381 5 : listOfMemoryPoolSizes [ 154 ] = globalIndexCounter;
382 5 : globalIndexCounter = SgFormatItem::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
383 5 : listOfMemoryPoolSizes [ 155 ] = globalIndexCounter;
384 5 : globalIndexCounter = SgFormatItemList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
385 5 : listOfMemoryPoolSizes [ 156 ] = globalIndexCounter;
386 5 : globalIndexCounter = SgFormatStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
387 5 : listOfMemoryPoolSizes [ 157 ] = globalIndexCounter;
388 5 : globalIndexCounter = SgFortranDo::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
389 5 : listOfMemoryPoolSizes [ 158 ] = globalIndexCounter;
390 5 : globalIndexCounter = SgFortranIncludeLine::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
391 5 : listOfMemoryPoolSizes [ 159 ] = globalIndexCounter;
392 5 : globalIndexCounter = SgFortranNonblockedDo::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
393 5 : listOfMemoryPoolSizes [ 160 ] = globalIndexCounter;
394 5 : globalIndexCounter = SgFuncDecl_attr::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
395 5 : listOfMemoryPoolSizes [ 161 ] = globalIndexCounter;
396 5 : globalIndexCounter = SgFunctionCallExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
397 5 : listOfMemoryPoolSizes [ 162 ] = globalIndexCounter;
398 5 : globalIndexCounter = SgFunctionDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
399 5 : listOfMemoryPoolSizes [ 163 ] = globalIndexCounter;
400 5 : globalIndexCounter = SgFunctionDefinition::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
401 5 : listOfMemoryPoolSizes [ 164 ] = globalIndexCounter;
402 5 : globalIndexCounter = SgFunctionParameterScope::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
403 5 : listOfMemoryPoolSizes [ 165 ] = globalIndexCounter;
404 5 : globalIndexCounter = SgFunctionModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
405 5 : listOfMemoryPoolSizes [ 166 ] = globalIndexCounter;
406 5 : globalIndexCounter = SgFunctionParameterList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
407 5 : listOfMemoryPoolSizes [ 167 ] = globalIndexCounter;
408 5 : globalIndexCounter = SgFunctionParameterRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
409 5 : listOfMemoryPoolSizes [ 168 ] = globalIndexCounter;
410 5 : globalIndexCounter = SgFunctionParameterTypeList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
411 5 : listOfMemoryPoolSizes [ 169 ] = globalIndexCounter;
412 5 : globalIndexCounter = SgFunctionRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
413 5 : listOfMemoryPoolSizes [ 170 ] = globalIndexCounter;
414 5 : globalIndexCounter = SgFunctionSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
415 5 : listOfMemoryPoolSizes [ 171 ] = globalIndexCounter;
416 5 : globalIndexCounter = SgFunctionType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
417 5 : listOfMemoryPoolSizes [ 172 ] = globalIndexCounter;
418 5 : globalIndexCounter = SgFunctionTypeSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
419 5 : listOfMemoryPoolSizes [ 173 ] = globalIndexCounter;
420 5 : globalIndexCounter = SgFunctionTypeTable::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
421 5 : listOfMemoryPoolSizes [ 174 ] = globalIndexCounter;
422 5 : globalIndexCounter = SgTypeTable::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
423 5 : listOfMemoryPoolSizes [ 175 ] = globalIndexCounter;
424 5 : globalIndexCounter = SgGlobal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
425 5 : listOfMemoryPoolSizes [ 176 ] = globalIndexCounter;
426 5 : globalIndexCounter = SgGotoStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
427 5 : listOfMemoryPoolSizes [ 177 ] = globalIndexCounter;
428 5 : globalIndexCounter = SgGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
429 5 : listOfMemoryPoolSizes [ 178 ] = globalIndexCounter;
430 5 : globalIndexCounter = SgGraphEdge::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
431 5 : listOfMemoryPoolSizes [ 179 ] = globalIndexCounter;
432 5 : globalIndexCounter = SgGraphEdgeList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
433 5 : listOfMemoryPoolSizes [ 180 ] = globalIndexCounter;
434 5 : globalIndexCounter = SgGraphNode::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
435 5 : listOfMemoryPoolSizes [ 181 ] = globalIndexCounter;
436 5 : globalIndexCounter = SgGraphNodeList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
437 5 : listOfMemoryPoolSizes [ 182 ] = globalIndexCounter;
438 5 : globalIndexCounter = SgGreaterOrEqualOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
439 5 : listOfMemoryPoolSizes [ 183 ] = globalIndexCounter;
440 5 : globalIndexCounter = SgGreaterThanOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
441 5 : listOfMemoryPoolSizes [ 184 ] = globalIndexCounter;
442 5 : globalIndexCounter = SgIOItemExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
443 5 : listOfMemoryPoolSizes [ 185 ] = globalIndexCounter;
444 5 : globalIndexCounter = SgIOStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
445 5 : listOfMemoryPoolSizes [ 186 ] = globalIndexCounter;
446 5 : globalIndexCounter = SgIdentDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
447 5 : listOfMemoryPoolSizes [ 187 ] = globalIndexCounter;
448 5 : globalIndexCounter = SgIfDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
449 5 : listOfMemoryPoolSizes [ 188 ] = globalIndexCounter;
450 5 : globalIndexCounter = SgIfStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
451 5 : listOfMemoryPoolSizes [ 189 ] = globalIndexCounter;
452 5 : globalIndexCounter = SgIfdefDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
453 5 : listOfMemoryPoolSizes [ 190 ] = globalIndexCounter;
454 5 : globalIndexCounter = SgIfndefDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
455 5 : listOfMemoryPoolSizes [ 191 ] = globalIndexCounter;
456 5 : globalIndexCounter = SgImageControlStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
457 5 : listOfMemoryPoolSizes [ 192 ] = globalIndexCounter;
458 5 : globalIndexCounter = SgImagPartOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
459 5 : listOfMemoryPoolSizes [ 193 ] = globalIndexCounter;
460 5 : globalIndexCounter = SgImplicitStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
461 5 : listOfMemoryPoolSizes [ 194 ] = globalIndexCounter;
462 5 : globalIndexCounter = SgImpliedDo::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
463 5 : listOfMemoryPoolSizes [ 195 ] = globalIndexCounter;
464 5 : globalIndexCounter = SgImportStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
465 5 : listOfMemoryPoolSizes [ 196 ] = globalIndexCounter;
466 5 : globalIndexCounter = SgIncidenceDirectedGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
467 5 : listOfMemoryPoolSizes [ 197 ] = globalIndexCounter;
468 5 : globalIndexCounter = SgIncidenceUndirectedGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
469 5 : listOfMemoryPoolSizes [ 198 ] = globalIndexCounter;
470 5 : globalIndexCounter = SgIncludeDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
471 5 : listOfMemoryPoolSizes [ 199 ] = globalIndexCounter;
472 5 : globalIndexCounter = SgIncludeFile::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
473 5 : listOfMemoryPoolSizes [ 200 ] = globalIndexCounter;
474 5 : globalIndexCounter = SgIncludeNextDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
475 5 : listOfMemoryPoolSizes [ 201 ] = globalIndexCounter;
476 5 : globalIndexCounter = SgInitializedName::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
477 5 : listOfMemoryPoolSizes [ 202 ] = globalIndexCounter;
478 5 : globalIndexCounter = SgInitializer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
479 5 : listOfMemoryPoolSizes [ 203 ] = globalIndexCounter;
480 5 : globalIndexCounter = SgInquireStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
481 5 : listOfMemoryPoolSizes [ 204 ] = globalIndexCounter;
482 5 : globalIndexCounter = SgIntKeyedBidirectionalGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
483 5 : listOfMemoryPoolSizes [ 205 ] = globalIndexCounter;
484 5 : globalIndexCounter = SgIntVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
485 5 : listOfMemoryPoolSizes [ 206 ] = globalIndexCounter;
486 5 : globalIndexCounter = SgIntegerDivideOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
487 5 : listOfMemoryPoolSizes [ 207 ] = globalIndexCounter;
488 5 : globalIndexCounter = SgIntegerDivideAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
489 5 : listOfMemoryPoolSizes [ 208 ] = globalIndexCounter;
490 5 : globalIndexCounter = SgInterfaceBody::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
491 5 : listOfMemoryPoolSizes [ 209 ] = globalIndexCounter;
492 5 : globalIndexCounter = SgHeaderFileBody::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
493 5 : listOfMemoryPoolSizes [ 210 ] = globalIndexCounter;
494 5 : globalIndexCounter = SgHeaderFileReport::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
495 5 : listOfMemoryPoolSizes [ 211 ] = globalIndexCounter;
496 5 : globalIndexCounter = SgInterfaceStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
497 5 : listOfMemoryPoolSizes [ 212 ] = globalIndexCounter;
498 5 : globalIndexCounter = SgInterfaceSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
499 5 : listOfMemoryPoolSizes [ 213 ] = globalIndexCounter;
500 5 : globalIndexCounter = SgIntrinsicSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
501 5 : listOfMemoryPoolSizes [ 214 ] = globalIndexCounter;
502 5 : globalIndexCounter = SgIsOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
503 5 : listOfMemoryPoolSizes [ 215 ] = globalIndexCounter;
504 5 : globalIndexCounter = SgIsNotOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
505 5 : listOfMemoryPoolSizes [ 216 ] = globalIndexCounter;
506 5 : globalIndexCounter = SgIorAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
507 5 : listOfMemoryPoolSizes [ 217 ] = globalIndexCounter;
508 5 : globalIndexCounter = SgKeyDatumPair::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
509 5 : listOfMemoryPoolSizes [ 218 ] = globalIndexCounter;
510 5 : globalIndexCounter = SgCudaKernelExecConfig::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
511 5 : listOfMemoryPoolSizes [ 219 ] = globalIndexCounter;
512 5 : globalIndexCounter = SgCudaKernelCallExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
513 5 : listOfMemoryPoolSizes [ 220 ] = globalIndexCounter;
514 5 : globalIndexCounter = SgLabelRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
515 5 : listOfMemoryPoolSizes [ 221 ] = globalIndexCounter;
516 5 : globalIndexCounter = SgLabelStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
517 5 : listOfMemoryPoolSizes [ 222 ] = globalIndexCounter;
518 5 : globalIndexCounter = SgLabelSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
519 5 : listOfMemoryPoolSizes [ 223 ] = globalIndexCounter;
520 5 : globalIndexCounter = SgLambdaCapture::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
521 5 : listOfMemoryPoolSizes [ 224 ] = globalIndexCounter;
522 5 : globalIndexCounter = SgLambdaCaptureList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
523 5 : listOfMemoryPoolSizes [ 225 ] = globalIndexCounter;
524 5 : globalIndexCounter = SgLambdaExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
525 5 : listOfMemoryPoolSizes [ 226 ] = globalIndexCounter;
526 5 : globalIndexCounter = SgLambdaRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
527 5 : listOfMemoryPoolSizes [ 227 ] = globalIndexCounter;
528 5 : globalIndexCounter = SgLeftDivideOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
529 5 : listOfMemoryPoolSizes [ 228 ] = globalIndexCounter;
530 5 : globalIndexCounter = SgLessOrEqualOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
531 5 : listOfMemoryPoolSizes [ 229 ] = globalIndexCounter;
532 5 : globalIndexCounter = SgLessThanOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
533 5 : listOfMemoryPoolSizes [ 230 ] = globalIndexCounter;
534 5 : globalIndexCounter = SgLineDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
535 5 : listOfMemoryPoolSizes [ 231 ] = globalIndexCounter;
536 5 : globalIndexCounter = SgLinemarkerDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
537 5 : listOfMemoryPoolSizes [ 232 ] = globalIndexCounter;
538 5 : globalIndexCounter = SgLinkageModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
539 5 : listOfMemoryPoolSizes [ 233 ] = globalIndexCounter;
540 5 : globalIndexCounter = SgListComprehension::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
541 5 : listOfMemoryPoolSizes [ 234 ] = globalIndexCounter;
542 5 : globalIndexCounter = SgListExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
543 5 : listOfMemoryPoolSizes [ 235 ] = globalIndexCounter;
544 5 : globalIndexCounter = SgLocatedNode::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
545 5 : listOfMemoryPoolSizes [ 236 ] = globalIndexCounter;
546 5 : globalIndexCounter = SgLocatedNodeSupport::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
547 5 : listOfMemoryPoolSizes [ 237 ] = globalIndexCounter;
548 5 : globalIndexCounter = SgLongDoubleVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
549 5 : listOfMemoryPoolSizes [ 238 ] = globalIndexCounter;
550 5 : globalIndexCounter = SgLongIntVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
551 5 : listOfMemoryPoolSizes [ 239 ] = globalIndexCounter;
552 5 : globalIndexCounter = SgLongLongIntVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
553 5 : listOfMemoryPoolSizes [ 240 ] = globalIndexCounter;
554 5 : globalIndexCounter = SgLshiftAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
555 5 : listOfMemoryPoolSizes [ 241 ] = globalIndexCounter;
556 5 : globalIndexCounter = SgLshiftOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
557 5 : listOfMemoryPoolSizes [ 242 ] = globalIndexCounter;
558 5 : globalIndexCounter = SgMagicColonExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
559 5 : listOfMemoryPoolSizes [ 243 ] = globalIndexCounter;
560 5 : globalIndexCounter = SgMatrixExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
561 5 : listOfMemoryPoolSizes [ 244 ] = globalIndexCounter;
562 5 : globalIndexCounter = SgMatrixTransposeOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
563 5 : listOfMemoryPoolSizes [ 245 ] = globalIndexCounter;
564 5 : globalIndexCounter = SgMemberFunctionDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
565 5 : listOfMemoryPoolSizes [ 246 ] = globalIndexCounter;
566 5 : globalIndexCounter = SgMemberFunctionRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
567 5 : listOfMemoryPoolSizes [ 247 ] = globalIndexCounter;
568 5 : globalIndexCounter = SgMemberFunctionSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
569 5 : listOfMemoryPoolSizes [ 248 ] = globalIndexCounter;
570 5 : globalIndexCounter = SgMemberFunctionType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
571 5 : listOfMemoryPoolSizes [ 249 ] = globalIndexCounter;
572 5 : globalIndexCounter = SgMembershipOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
573 5 : listOfMemoryPoolSizes [ 250 ] = globalIndexCounter;
574 5 : globalIndexCounter = SgMicrosoftAttributeDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
575 5 : listOfMemoryPoolSizes [ 251 ] = globalIndexCounter;
576 5 : globalIndexCounter = SgMinusAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
577 5 : listOfMemoryPoolSizes [ 252 ] = globalIndexCounter;
578 5 : globalIndexCounter = SgMinusMinusOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
579 5 : listOfMemoryPoolSizes [ 253 ] = globalIndexCounter;
580 5 : globalIndexCounter = SgMinusOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
581 5 : listOfMemoryPoolSizes [ 254 ] = globalIndexCounter;
582 5 : globalIndexCounter = SgModAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
583 5 : listOfMemoryPoolSizes [ 255 ] = globalIndexCounter;
584 5 : globalIndexCounter = SgModOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
585 5 : listOfMemoryPoolSizes [ 256 ] = globalIndexCounter;
586 5 : globalIndexCounter = SgModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
587 5 : listOfMemoryPoolSizes [ 257 ] = globalIndexCounter;
588 5 : globalIndexCounter = SgModifierNodes::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
589 5 : listOfMemoryPoolSizes [ 258 ] = globalIndexCounter;
590 5 : globalIndexCounter = SgModifierType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
591 5 : listOfMemoryPoolSizes [ 259 ] = globalIndexCounter;
592 5 : globalIndexCounter = SgModuleStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
593 5 : listOfMemoryPoolSizes [ 260 ] = globalIndexCounter;
594 5 : globalIndexCounter = SgModuleSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
595 5 : listOfMemoryPoolSizes [ 261 ] = globalIndexCounter;
596 5 : globalIndexCounter = SgMultAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
597 5 : listOfMemoryPoolSizes [ 262 ] = globalIndexCounter;
598 5 : globalIndexCounter = SgMultiplyOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
599 5 : listOfMemoryPoolSizes [ 263 ] = globalIndexCounter;
600 5 : globalIndexCounter = SgName::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
601 5 : listOfMemoryPoolSizes [ 264 ] = globalIndexCounter;
602 5 : globalIndexCounter = SgNameGroup::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
603 5 : listOfMemoryPoolSizes [ 265 ] = globalIndexCounter;
604 5 : globalIndexCounter = SgNamedType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
605 5 : listOfMemoryPoolSizes [ 266 ] = globalIndexCounter;
606 5 : globalIndexCounter = SgNamelistStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
607 5 : listOfMemoryPoolSizes [ 267 ] = globalIndexCounter;
608 5 : globalIndexCounter = SgNamespaceAliasDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
609 5 : listOfMemoryPoolSizes [ 268 ] = globalIndexCounter;
610 5 : globalIndexCounter = SgNamespaceDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
611 5 : listOfMemoryPoolSizes [ 269 ] = globalIndexCounter;
612 5 : globalIndexCounter = SgNamespaceDefinitionStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
613 5 : listOfMemoryPoolSizes [ 270 ] = globalIndexCounter;
614 5 : globalIndexCounter = SgNamespaceSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
615 5 : listOfMemoryPoolSizes [ 271 ] = globalIndexCounter;
616 5 : globalIndexCounter = SgNaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
617 5 : listOfMemoryPoolSizes [ 272 ] = globalIndexCounter;
618 5 : globalIndexCounter = SgNaryBooleanOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
619 5 : listOfMemoryPoolSizes [ 273 ] = globalIndexCounter;
620 5 : globalIndexCounter = SgNaryComparisonOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
621 5 : listOfMemoryPoolSizes [ 274 ] = globalIndexCounter;
622 5 : globalIndexCounter = SgNewExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
623 5 : listOfMemoryPoolSizes [ 275 ] = globalIndexCounter;
624 5 : globalIndexCounter = SgNode::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
625 5 : listOfMemoryPoolSizes [ 276 ] = globalIndexCounter;
626 5 : globalIndexCounter = SgNoexceptOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
627 5 : listOfMemoryPoolSizes [ 277 ] = globalIndexCounter;
628 5 : globalIndexCounter = SgNotEqualOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
629 5 : listOfMemoryPoolSizes [ 278 ] = globalIndexCounter;
630 5 : globalIndexCounter = SgNotOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
631 5 : listOfMemoryPoolSizes [ 279 ] = globalIndexCounter;
632 5 : globalIndexCounter = SgNonMembershipOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
633 5 : listOfMemoryPoolSizes [ 280 ] = globalIndexCounter;
634 5 : globalIndexCounter = SgNonrealDecl::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
635 5 : listOfMemoryPoolSizes [ 281 ] = globalIndexCounter;
636 5 : globalIndexCounter = SgNonrealRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
637 5 : listOfMemoryPoolSizes [ 282 ] = globalIndexCounter;
638 5 : globalIndexCounter = SgNonrealSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
639 5 : listOfMemoryPoolSizes [ 283 ] = globalIndexCounter;
640 5 : globalIndexCounter = SgNonrealType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
641 5 : listOfMemoryPoolSizes [ 284 ] = globalIndexCounter;
642 5 : globalIndexCounter = SgNonrealBaseClass::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
643 5 : listOfMemoryPoolSizes [ 285 ] = globalIndexCounter;
644 5 : globalIndexCounter = SgNullExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
645 5 : listOfMemoryPoolSizes [ 286 ] = globalIndexCounter;
646 5 : globalIndexCounter = SgNullptrValExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
647 5 : listOfMemoryPoolSizes [ 287 ] = globalIndexCounter;
648 5 : globalIndexCounter = SgNullStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
649 5 : listOfMemoryPoolSizes [ 288 ] = globalIndexCounter;
650 5 : globalIndexCounter = SgNullifyStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
651 5 : listOfMemoryPoolSizes [ 289 ] = globalIndexCounter;
652 5 : globalIndexCounter = SgOmpAtomicStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
653 5 : listOfMemoryPoolSizes [ 290 ] = globalIndexCounter;
654 5 : globalIndexCounter = SgOmpBarrierStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
655 5 : listOfMemoryPoolSizes [ 291 ] = globalIndexCounter;
656 5 : globalIndexCounter = SgOmpCriticalStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
657 5 : listOfMemoryPoolSizes [ 292 ] = globalIndexCounter;
658 5 : globalIndexCounter = SgUpirFieldBodyStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
659 5 : listOfMemoryPoolSizes [ 293 ] = globalIndexCounter;
660 5 : globalIndexCounter = SgUpirBodyStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
661 5 : listOfMemoryPoolSizes [ 294 ] = globalIndexCounter;
662 5 : globalIndexCounter = SgUpirFieldStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
663 5 : listOfMemoryPoolSizes [ 295 ] = globalIndexCounter;
664 5 : globalIndexCounter = SgOmpDoStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
665 5 : listOfMemoryPoolSizes [ 296 ] = globalIndexCounter;
666 5 : globalIndexCounter = SgOmpFlushStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
667 5 : listOfMemoryPoolSizes [ 297 ] = globalIndexCounter;
668 5 : globalIndexCounter = SgOmpAllocateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
669 5 : listOfMemoryPoolSizes [ 298 ] = globalIndexCounter;
670 5 : globalIndexCounter = SgOmpDeclareSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
671 5 : listOfMemoryPoolSizes [ 299 ] = globalIndexCounter;
672 5 : globalIndexCounter = SgUpirWorksharingStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
673 5 : listOfMemoryPoolSizes [ 300 ] = globalIndexCounter;
674 5 : globalIndexCounter = SgOmpForSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
675 5 : listOfMemoryPoolSizes [ 301 ] = globalIndexCounter;
676 5 : globalIndexCounter = SgOmpMasterStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
677 5 : listOfMemoryPoolSizes [ 302 ] = globalIndexCounter;
678 5 : globalIndexCounter = SgOmpTaskyieldStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
679 5 : listOfMemoryPoolSizes [ 303 ] = globalIndexCounter;
680 5 : globalIndexCounter = SgOmpMetadirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
681 5 : listOfMemoryPoolSizes [ 304 ] = globalIndexCounter;
682 5 : globalIndexCounter = SgOmpOrderedStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
683 5 : listOfMemoryPoolSizes [ 305 ] = globalIndexCounter;
684 5 : globalIndexCounter = SgOmpOrderedDependStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
685 5 : listOfMemoryPoolSizes [ 306 ] = globalIndexCounter;
686 5 : globalIndexCounter = SgUpirSpmdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
687 5 : listOfMemoryPoolSizes [ 307 ] = globalIndexCounter;
688 5 : globalIndexCounter = SgOmpTeamsStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
689 5 : listOfMemoryPoolSizes [ 308 ] = globalIndexCounter;
690 5 : globalIndexCounter = SgOmpCancellationPointStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
691 5 : listOfMemoryPoolSizes [ 309 ] = globalIndexCounter;
692 5 : globalIndexCounter = SgOmpDeclareMapperStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
693 5 : listOfMemoryPoolSizes [ 310 ] = globalIndexCounter;
694 5 : globalIndexCounter = SgOmpCancelStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
695 5 : listOfMemoryPoolSizes [ 311 ] = globalIndexCounter;
696 5 : globalIndexCounter = SgOmpTaskgroupStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
697 5 : listOfMemoryPoolSizes [ 312 ] = globalIndexCounter;
698 5 : globalIndexCounter = SgOmpDepobjStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
699 5 : listOfMemoryPoolSizes [ 313 ] = globalIndexCounter;
700 5 : globalIndexCounter = SgOmpDistributeStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
701 5 : listOfMemoryPoolSizes [ 314 ] = globalIndexCounter;
702 5 : globalIndexCounter = SgOmpLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
703 5 : listOfMemoryPoolSizes [ 315 ] = globalIndexCounter;
704 5 : globalIndexCounter = SgOmpScanStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
705 5 : listOfMemoryPoolSizes [ 316 ] = globalIndexCounter;
706 5 : globalIndexCounter = SgOmpTaskloopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
707 5 : listOfMemoryPoolSizes [ 317 ] = globalIndexCounter;
708 5 : globalIndexCounter = SgOmpTargetEnterDataStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
709 5 : listOfMemoryPoolSizes [ 318 ] = globalIndexCounter;
710 5 : globalIndexCounter = SgOmpTargetExitDataStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
711 5 : listOfMemoryPoolSizes [ 319 ] = globalIndexCounter;
712 5 : globalIndexCounter = SgOmpSectionStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
713 5 : listOfMemoryPoolSizes [ 320 ] = globalIndexCounter;
714 5 : globalIndexCounter = SgOmpSectionsStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
715 5 : listOfMemoryPoolSizes [ 321 ] = globalIndexCounter;
716 5 : globalIndexCounter = SgOmpSingleStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
717 5 : listOfMemoryPoolSizes [ 322 ] = globalIndexCounter;
718 5 : globalIndexCounter = SgOmpTaskStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
719 5 : listOfMemoryPoolSizes [ 323 ] = globalIndexCounter;
720 5 : globalIndexCounter = SgOmpTaskwaitStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
721 5 : listOfMemoryPoolSizes [ 324 ] = globalIndexCounter;
722 5 : globalIndexCounter = SgOmpThreadprivateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
723 5 : listOfMemoryPoolSizes [ 325 ] = globalIndexCounter;
724 5 : globalIndexCounter = SgOmpWorkshareStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
725 5 : listOfMemoryPoolSizes [ 326 ] = globalIndexCounter;
726 5 : globalIndexCounter = SgUpirTaskStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
727 5 : listOfMemoryPoolSizes [ 327 ] = globalIndexCounter;
728 5 : globalIndexCounter = SgOmpTargetDataStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
729 5 : listOfMemoryPoolSizes [ 328 ] = globalIndexCounter;
730 5 : globalIndexCounter = SgOmpTargetParallelForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
731 5 : listOfMemoryPoolSizes [ 329 ] = globalIndexCounter;
732 5 : globalIndexCounter = SgOmpTargetUpdateStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
733 5 : listOfMemoryPoolSizes [ 330 ] = globalIndexCounter;
734 5 : globalIndexCounter = SgOmpRequiresStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
735 5 : listOfMemoryPoolSizes [ 331 ] = globalIndexCounter;
736 5 : globalIndexCounter = SgOmpTargetParallelStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
737 5 : listOfMemoryPoolSizes [ 332 ] = globalIndexCounter;
738 5 : globalIndexCounter = SgOmpTargetParallelForSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
739 5 : listOfMemoryPoolSizes [ 333 ] = globalIndexCounter;
740 5 : globalIndexCounter = SgOmpTargetParallelLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
741 5 : listOfMemoryPoolSizes [ 334 ] = globalIndexCounter;
742 5 : globalIndexCounter = SgOmpTargetSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
743 5 : listOfMemoryPoolSizes [ 335 ] = globalIndexCounter;
744 5 : globalIndexCounter = SgOmpTargetTeamsStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
745 5 : listOfMemoryPoolSizes [ 336 ] = globalIndexCounter;
746 5 : globalIndexCounter = SgOmpTargetTeamsDistributeStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
747 5 : listOfMemoryPoolSizes [ 337 ] = globalIndexCounter;
748 5 : globalIndexCounter = SgOmpTargetTeamsDistributeSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
749 5 : listOfMemoryPoolSizes [ 338 ] = globalIndexCounter;
750 5 : globalIndexCounter = SgOmpTargetTeamsLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
751 5 : listOfMemoryPoolSizes [ 339 ] = globalIndexCounter;
752 5 : globalIndexCounter = SgOmpTargetTeamsDistributeParallelForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
753 5 : listOfMemoryPoolSizes [ 340 ] = globalIndexCounter;
754 5 : globalIndexCounter = SgOmpTargetTeamsDistributeParallelForSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
755 5 : listOfMemoryPoolSizes [ 341 ] = globalIndexCounter;
756 5 : globalIndexCounter = SgOmpDistributeSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
757 5 : listOfMemoryPoolSizes [ 342 ] = globalIndexCounter;
758 5 : globalIndexCounter = SgOmpDistributeParallelForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
759 5 : listOfMemoryPoolSizes [ 343 ] = globalIndexCounter;
760 5 : globalIndexCounter = SgOmpDistributeParallelForSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
761 5 : listOfMemoryPoolSizes [ 344 ] = globalIndexCounter;
762 5 : globalIndexCounter = SgOmpTaskloopSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
763 5 : listOfMemoryPoolSizes [ 345 ] = globalIndexCounter;
764 5 : globalIndexCounter = SgOmpMasterTaskloopSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
765 5 : listOfMemoryPoolSizes [ 346 ] = globalIndexCounter;
766 5 : globalIndexCounter = SgOmpParallelMasterTaskloopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
767 5 : listOfMemoryPoolSizes [ 347 ] = globalIndexCounter;
768 5 : globalIndexCounter = SgOmpParallelMasterTaskloopSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
769 5 : listOfMemoryPoolSizes [ 348 ] = globalIndexCounter;
770 5 : globalIndexCounter = SgOmpTeamsDistributeStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
771 5 : listOfMemoryPoolSizes [ 349 ] = globalIndexCounter;
772 5 : globalIndexCounter = SgOmpTeamsDistributeSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
773 5 : listOfMemoryPoolSizes [ 350 ] = globalIndexCounter;
774 5 : globalIndexCounter = SgOmpTeamsDistributeParallelForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
775 5 : listOfMemoryPoolSizes [ 351 ] = globalIndexCounter;
776 5 : globalIndexCounter = SgOmpTeamsDistributeParallelForSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
777 5 : listOfMemoryPoolSizes [ 352 ] = globalIndexCounter;
778 5 : globalIndexCounter = SgOmpTeamsLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
779 5 : listOfMemoryPoolSizes [ 353 ] = globalIndexCounter;
780 5 : globalIndexCounter = SgOmpParallelLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
781 5 : listOfMemoryPoolSizes [ 354 ] = globalIndexCounter;
782 5 : globalIndexCounter = SgOmpParallelMasterStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
783 5 : listOfMemoryPoolSizes [ 355 ] = globalIndexCounter;
784 5 : globalIndexCounter = SgOmpMasterTaskloopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
785 5 : listOfMemoryPoolSizes [ 356 ] = globalIndexCounter;
786 5 : globalIndexCounter = SgOmpUnrollStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
787 5 : listOfMemoryPoolSizes [ 357 ] = globalIndexCounter;
788 5 : globalIndexCounter = SgOmpTileStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
789 5 : listOfMemoryPoolSizes [ 358 ] = globalIndexCounter;
790 5 : globalIndexCounter = SgUpirSimdStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
791 5 : listOfMemoryPoolSizes [ 359 ] = globalIndexCounter;
792 5 : globalIndexCounter = SgUpirBaseStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
793 5 : listOfMemoryPoolSizes [ 360 ] = globalIndexCounter;
794 5 : globalIndexCounter = SgUpirLoopStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
795 5 : listOfMemoryPoolSizes [ 361 ] = globalIndexCounter;
796 5 : globalIndexCounter = SgUpirLoopParallelStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
797 5 : listOfMemoryPoolSizes [ 362 ] = globalIndexCounter;
798 5 : globalIndexCounter = SgUpirSyncStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
799 5 : listOfMemoryPoolSizes [ 363 ] = globalIndexCounter;
800 5 : globalIndexCounter = SgOmpClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
801 5 : listOfMemoryPoolSizes [ 364 ] = globalIndexCounter;
802 5 : globalIndexCounter = SgOmpAllocateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
803 5 : listOfMemoryPoolSizes [ 365 ] = globalIndexCounter;
804 5 : globalIndexCounter = SgOmpAllocatorClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
805 5 : listOfMemoryPoolSizes [ 366 ] = globalIndexCounter;
806 5 : globalIndexCounter = SgOmpUsesAllocatorsClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
807 5 : listOfMemoryPoolSizes [ 367 ] = globalIndexCounter;
808 5 : globalIndexCounter = SgOmpUsesAllocatorsDefination::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
809 5 : listOfMemoryPoolSizes [ 368 ] = globalIndexCounter;
810 5 : globalIndexCounter = SgOmpToClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
811 5 : listOfMemoryPoolSizes [ 369 ] = globalIndexCounter;
812 5 : globalIndexCounter = SgOmpFromClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
813 5 : listOfMemoryPoolSizes [ 370 ] = globalIndexCounter;
814 5 : globalIndexCounter = SgOmpThreadsClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
815 5 : listOfMemoryPoolSizes [ 371 ] = globalIndexCounter;
816 5 : globalIndexCounter = SgOmpSimdClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
817 5 : listOfMemoryPoolSizes [ 372 ] = globalIndexCounter;
818 5 : globalIndexCounter = SgOmpBeginClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
819 5 : listOfMemoryPoolSizes [ 373 ] = globalIndexCounter;
820 5 : globalIndexCounter = SgOmpCollapseClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
821 5 : listOfMemoryPoolSizes [ 374 ] = globalIndexCounter;
822 5 : globalIndexCounter = SgOmpCopyinClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
823 5 : listOfMemoryPoolSizes [ 375 ] = globalIndexCounter;
824 5 : globalIndexCounter = SgOmpCopyprivateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
825 5 : listOfMemoryPoolSizes [ 376 ] = globalIndexCounter;
826 5 : globalIndexCounter = SgOmpDefaultClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
827 5 : listOfMemoryPoolSizes [ 377 ] = globalIndexCounter;
828 5 : globalIndexCounter = SgOmpEndClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
829 5 : listOfMemoryPoolSizes [ 378 ] = globalIndexCounter;
830 5 : globalIndexCounter = SgOmpExpressionClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
831 5 : listOfMemoryPoolSizes [ 379 ] = globalIndexCounter;
832 5 : globalIndexCounter = SgOmpFirstprivateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
833 5 : listOfMemoryPoolSizes [ 380 ] = globalIndexCounter;
834 5 : globalIndexCounter = SgOmpIfClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
835 5 : listOfMemoryPoolSizes [ 381 ] = globalIndexCounter;
836 5 : globalIndexCounter = SgOmpFinalClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
837 5 : listOfMemoryPoolSizes [ 382 ] = globalIndexCounter;
838 5 : globalIndexCounter = SgOmpPriorityClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
839 5 : listOfMemoryPoolSizes [ 383 ] = globalIndexCounter;
840 5 : globalIndexCounter = SgOmpDeviceClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
841 5 : listOfMemoryPoolSizes [ 384 ] = globalIndexCounter;
842 5 : globalIndexCounter = SgOmpLastprivateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
843 5 : listOfMemoryPoolSizes [ 385 ] = globalIndexCounter;
844 5 : globalIndexCounter = SgOmpNowaitClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
845 5 : listOfMemoryPoolSizes [ 386 ] = globalIndexCounter;
846 5 : globalIndexCounter = SgOmpReadClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
847 5 : listOfMemoryPoolSizes [ 387 ] = globalIndexCounter;
848 5 : globalIndexCounter = SgOmpWriteClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
849 5 : listOfMemoryPoolSizes [ 388 ] = globalIndexCounter;
850 5 : globalIndexCounter = SgOmpUpdateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
851 5 : listOfMemoryPoolSizes [ 389 ] = globalIndexCounter;
852 5 : globalIndexCounter = SgOmpDepobjUpdateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
853 5 : listOfMemoryPoolSizes [ 390 ] = globalIndexCounter;
854 5 : globalIndexCounter = SgOmpDestroyClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
855 5 : listOfMemoryPoolSizes [ 391 ] = globalIndexCounter;
856 5 : globalIndexCounter = SgOmpCaptureClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
857 5 : listOfMemoryPoolSizes [ 392 ] = globalIndexCounter;
858 5 : globalIndexCounter = SgOmpSeqCstClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
859 5 : listOfMemoryPoolSizes [ 393 ] = globalIndexCounter;
860 5 : globalIndexCounter = SgOmpAcqRelClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
861 5 : listOfMemoryPoolSizes [ 394 ] = globalIndexCounter;
862 5 : globalIndexCounter = SgOmpReleaseClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
863 5 : listOfMemoryPoolSizes [ 395 ] = globalIndexCounter;
864 5 : globalIndexCounter = SgOmpAcquireClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
865 5 : listOfMemoryPoolSizes [ 396 ] = globalIndexCounter;
866 5 : globalIndexCounter = SgOmpReverseOffloadClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
867 5 : listOfMemoryPoolSizes [ 397 ] = globalIndexCounter;
868 5 : globalIndexCounter = SgOmpUnifiedAddressClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
869 5 : listOfMemoryPoolSizes [ 398 ] = globalIndexCounter;
870 5 : globalIndexCounter = SgOmpUnifiedSharedMemoryClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
871 5 : listOfMemoryPoolSizes [ 399 ] = globalIndexCounter;
872 5 : globalIndexCounter = SgOmpDynamicAllocatorsClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
873 5 : listOfMemoryPoolSizes [ 400 ] = globalIndexCounter;
874 5 : globalIndexCounter = SgOmpAtomicDefaultMemOrderClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
875 5 : listOfMemoryPoolSizes [ 401 ] = globalIndexCounter;
876 5 : globalIndexCounter = SgOmpExtImplementationDefinedRequirementClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
877 5 : listOfMemoryPoolSizes [ 402 ] = globalIndexCounter;
878 5 : globalIndexCounter = SgOmpRelaxedClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
879 5 : listOfMemoryPoolSizes [ 403 ] = globalIndexCounter;
880 5 : globalIndexCounter = SgOmpParallelClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
881 5 : listOfMemoryPoolSizes [ 404 ] = globalIndexCounter;
882 5 : globalIndexCounter = SgOmpSectionsClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
883 5 : listOfMemoryPoolSizes [ 405 ] = globalIndexCounter;
884 5 : globalIndexCounter = SgOmpForClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
885 5 : listOfMemoryPoolSizes [ 406 ] = globalIndexCounter;
886 5 : globalIndexCounter = SgOmpTaskgroupClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
887 5 : listOfMemoryPoolSizes [ 407 ] = globalIndexCounter;
888 5 : globalIndexCounter = SgUpirNumUnitsField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
889 5 : listOfMemoryPoolSizes [ 408 ] = globalIndexCounter;
890 5 : globalIndexCounter = SgOmpNumTeamsClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
891 5 : listOfMemoryPoolSizes [ 409 ] = globalIndexCounter;
892 5 : globalIndexCounter = SgOmpGrainsizeClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
893 5 : listOfMemoryPoolSizes [ 410 ] = globalIndexCounter;
894 5 : globalIndexCounter = SgOmpDetachClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
895 5 : listOfMemoryPoolSizes [ 411 ] = globalIndexCounter;
896 5 : globalIndexCounter = SgOmpNumTasksClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
897 5 : listOfMemoryPoolSizes [ 412 ] = globalIndexCounter;
898 5 : globalIndexCounter = SgOmpNogroupClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
899 5 : listOfMemoryPoolSizes [ 413 ] = globalIndexCounter;
900 5 : globalIndexCounter = SgOmpHintClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
901 5 : listOfMemoryPoolSizes [ 414 ] = globalIndexCounter;
902 5 : globalIndexCounter = SgOmpOrderClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
903 5 : listOfMemoryPoolSizes [ 415 ] = globalIndexCounter;
904 5 : globalIndexCounter = SgOmpDistScheduleClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
905 5 : listOfMemoryPoolSizes [ 416 ] = globalIndexCounter;
906 5 : globalIndexCounter = SgOmpBindClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
907 5 : listOfMemoryPoolSizes [ 417 ] = globalIndexCounter;
908 5 : globalIndexCounter = SgOmpNontemporalClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
909 5 : listOfMemoryPoolSizes [ 418 ] = globalIndexCounter;
910 5 : globalIndexCounter = SgOmpInclusiveClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
911 5 : listOfMemoryPoolSizes [ 419 ] = globalIndexCounter;
912 5 : globalIndexCounter = SgOmpExclusiveClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
913 5 : listOfMemoryPoolSizes [ 420 ] = globalIndexCounter;
914 5 : globalIndexCounter = SgOmpIsDevicePtrClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
915 5 : listOfMemoryPoolSizes [ 421 ] = globalIndexCounter;
916 5 : globalIndexCounter = SgOmpUseDevicePtrClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
917 5 : listOfMemoryPoolSizes [ 422 ] = globalIndexCounter;
918 5 : globalIndexCounter = SgOmpUseDeviceAddrClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
919 5 : listOfMemoryPoolSizes [ 423 ] = globalIndexCounter;
920 5 : globalIndexCounter = SgOmpThreadLimitClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
921 5 : listOfMemoryPoolSizes [ 424 ] = globalIndexCounter;
922 5 : globalIndexCounter = SgOmpOrderedClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
923 5 : listOfMemoryPoolSizes [ 425 ] = globalIndexCounter;
924 5 : globalIndexCounter = SgOmpPrivateClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
925 5 : listOfMemoryPoolSizes [ 426 ] = globalIndexCounter;
926 5 : globalIndexCounter = SgOmpReductionClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
927 5 : listOfMemoryPoolSizes [ 427 ] = globalIndexCounter;
928 5 : globalIndexCounter = SgOmpInReductionClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
929 5 : listOfMemoryPoolSizes [ 428 ] = globalIndexCounter;
930 5 : globalIndexCounter = SgOmpTaskReductionClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
931 5 : listOfMemoryPoolSizes [ 429 ] = globalIndexCounter;
932 5 : globalIndexCounter = SgOmpDefaultmapClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
933 5 : listOfMemoryPoolSizes [ 430 ] = globalIndexCounter;
934 5 : globalIndexCounter = SgOmpScheduleClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
935 5 : listOfMemoryPoolSizes [ 431 ] = globalIndexCounter;
936 5 : globalIndexCounter = SgOmpSharedClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
937 5 : listOfMemoryPoolSizes [ 432 ] = globalIndexCounter;
938 5 : globalIndexCounter = SgOmpUntiedClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
939 5 : listOfMemoryPoolSizes [ 433 ] = globalIndexCounter;
940 5 : globalIndexCounter = SgOmpMergeableClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
941 5 : listOfMemoryPoolSizes [ 434 ] = globalIndexCounter;
942 5 : globalIndexCounter = SgOmpVariablesClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
943 5 : listOfMemoryPoolSizes [ 435 ] = globalIndexCounter;
944 5 : globalIndexCounter = SgOmpMapClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
945 5 : listOfMemoryPoolSizes [ 436 ] = globalIndexCounter;
946 5 : globalIndexCounter = SgOmpSafelenClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
947 5 : listOfMemoryPoolSizes [ 437 ] = globalIndexCounter;
948 5 : globalIndexCounter = SgOmpSimdlenClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
949 5 : listOfMemoryPoolSizes [ 438 ] = globalIndexCounter;
950 5 : globalIndexCounter = SgOmpLinearClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
951 5 : listOfMemoryPoolSizes [ 439 ] = globalIndexCounter;
952 5 : globalIndexCounter = SgOmpUniformClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
953 5 : listOfMemoryPoolSizes [ 440 ] = globalIndexCounter;
954 5 : globalIndexCounter = SgOmpAlignedClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
955 5 : listOfMemoryPoolSizes [ 441 ] = globalIndexCounter;
956 5 : globalIndexCounter = SgOmpProcBindClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
957 5 : listOfMemoryPoolSizes [ 442 ] = globalIndexCounter;
958 5 : globalIndexCounter = SgOmpAtomicClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
959 5 : listOfMemoryPoolSizes [ 443 ] = globalIndexCounter;
960 5 : globalIndexCounter = SgOmpInbranchClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
961 5 : listOfMemoryPoolSizes [ 444 ] = globalIndexCounter;
962 5 : globalIndexCounter = SgOmpNotinbranchClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
963 5 : listOfMemoryPoolSizes [ 445 ] = globalIndexCounter;
964 5 : globalIndexCounter = SgOmpDependClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
965 5 : listOfMemoryPoolSizes [ 446 ] = globalIndexCounter;
966 5 : globalIndexCounter = SgOmpAffinityClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
967 5 : listOfMemoryPoolSizes [ 447 ] = globalIndexCounter;
968 5 : globalIndexCounter = SgOmpWhenClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
969 5 : listOfMemoryPoolSizes [ 448 ] = globalIndexCounter;
970 5 : globalIndexCounter = SgOmpFullClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
971 5 : listOfMemoryPoolSizes [ 449 ] = globalIndexCounter;
972 5 : globalIndexCounter = SgOmpPartialClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
973 5 : listOfMemoryPoolSizes [ 450 ] = globalIndexCounter;
974 5 : globalIndexCounter = SgOmpSizesClause::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
975 5 : listOfMemoryPoolSizes [ 451 ] = globalIndexCounter;
976 5 : globalIndexCounter = SgUpirBranchField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
977 5 : listOfMemoryPoolSizes [ 452 ] = globalIndexCounter;
978 5 : globalIndexCounter = SgUpirNestedLevelField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
979 5 : listOfMemoryPoolSizes [ 453 ] = globalIndexCounter;
980 5 : globalIndexCounter = SgUpirNestedParentField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
981 5 : listOfMemoryPoolSizes [ 454 ] = globalIndexCounter;
982 5 : globalIndexCounter = SgUpirNestedChildField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
983 5 : listOfMemoryPoolSizes [ 455 ] = globalIndexCounter;
984 5 : globalIndexCounter = SgUpirSyncField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
985 5 : listOfMemoryPoolSizes [ 456 ] = globalIndexCounter;
986 5 : globalIndexCounter = SgUpirDataField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
987 5 : listOfMemoryPoolSizes [ 457 ] = globalIndexCounter;
988 5 : globalIndexCounter = SgUpirDataItemField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
989 5 : listOfMemoryPoolSizes [ 458 ] = globalIndexCounter;
990 5 : globalIndexCounter = SgUpirTargetField::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
991 5 : listOfMemoryPoolSizes [ 459 ] = globalIndexCounter;
992 5 : globalIndexCounter = SgOpenclAccessModeModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
993 5 : listOfMemoryPoolSizes [ 460 ] = globalIndexCounter;
994 5 : globalIndexCounter = SgOpenStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
995 5 : listOfMemoryPoolSizes [ 461 ] = globalIndexCounter;
996 5 : globalIndexCounter = SgOptions::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
997 5 : listOfMemoryPoolSizes [ 462 ] = globalIndexCounter;
998 5 : globalIndexCounter = SgOrOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
999 5 : listOfMemoryPoolSizes [ 463 ] = globalIndexCounter;
1000 5 : globalIndexCounter = SgParameterStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1001 5 : listOfMemoryPoolSizes [ 464 ] = globalIndexCounter;
1002 5 : globalIndexCounter = SgPartialFunctionModifierType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1003 5 : listOfMemoryPoolSizes [ 465 ] = globalIndexCounter;
1004 5 : globalIndexCounter = SgPartialFunctionType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1005 5 : listOfMemoryPoolSizes [ 466 ] = globalIndexCounter;
1006 5 : globalIndexCounter = SgPassStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1007 5 : listOfMemoryPoolSizes [ 467 ] = globalIndexCounter;
1008 5 : globalIndexCounter = SgPlusAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1009 5 : listOfMemoryPoolSizes [ 468 ] = globalIndexCounter;
1010 5 : globalIndexCounter = SgPlusPlusOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1011 5 : listOfMemoryPoolSizes [ 469 ] = globalIndexCounter;
1012 5 : globalIndexCounter = SgPntrArrRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1013 5 : listOfMemoryPoolSizes [ 470 ] = globalIndexCounter;
1014 5 : globalIndexCounter = SgPointerAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1015 5 : listOfMemoryPoolSizes [ 471 ] = globalIndexCounter;
1016 5 : globalIndexCounter = SgPointerDerefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1017 5 : listOfMemoryPoolSizes [ 472 ] = globalIndexCounter;
1018 5 : globalIndexCounter = SgPointerMemberType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1019 5 : listOfMemoryPoolSizes [ 473 ] = globalIndexCounter;
1020 5 : globalIndexCounter = SgPointerType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1021 5 : listOfMemoryPoolSizes [ 474 ] = globalIndexCounter;
1022 5 : globalIndexCounter = SgPowerOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1023 5 : listOfMemoryPoolSizes [ 475 ] = globalIndexCounter;
1024 5 : globalIndexCounter = SgPragma::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1025 5 : listOfMemoryPoolSizes [ 476 ] = globalIndexCounter;
1026 5 : globalIndexCounter = SgPragmaDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1027 5 : listOfMemoryPoolSizes [ 477 ] = globalIndexCounter;
1028 5 : globalIndexCounter = SgPrintStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1029 5 : listOfMemoryPoolSizes [ 478 ] = globalIndexCounter;
1030 5 : globalIndexCounter = SgProcedureHeaderStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1031 5 : listOfMemoryPoolSizes [ 479 ] = globalIndexCounter;
1032 5 : globalIndexCounter = SgProgramHeaderStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1033 5 : listOfMemoryPoolSizes [ 480 ] = globalIndexCounter;
1034 5 : globalIndexCounter = SgProject::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1035 5 : listOfMemoryPoolSizes [ 481 ] = globalIndexCounter;
1036 5 : globalIndexCounter = SgPseudoDestructorRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1037 5 : listOfMemoryPoolSizes [ 482 ] = globalIndexCounter;
1038 5 : listOfMemoryPoolSizes [ 483 ] = globalIndexCounter;
1039 5 : listOfMemoryPoolSizes [ 484 ] = globalIndexCounter;
1040 5 : globalIndexCounter = SgQualifiedName::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1041 5 : listOfMemoryPoolSizes [ 485 ] = globalIndexCounter;
1042 5 : globalIndexCounter = SgQualifiedNameType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1043 5 : listOfMemoryPoolSizes [ 486 ] = globalIndexCounter;
1044 5 : globalIndexCounter = SgRangeExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1045 5 : listOfMemoryPoolSizes [ 487 ] = globalIndexCounter;
1046 5 : globalIndexCounter = SgRangeBasedForStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1047 5 : listOfMemoryPoolSizes [ 488 ] = globalIndexCounter;
1048 5 : globalIndexCounter = SgReadStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1049 5 : listOfMemoryPoolSizes [ 489 ] = globalIndexCounter;
1050 5 : globalIndexCounter = SgRealPartOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1051 5 : listOfMemoryPoolSizes [ 490 ] = globalIndexCounter;
1052 5 : globalIndexCounter = SgRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1053 5 : listOfMemoryPoolSizes [ 491 ] = globalIndexCounter;
1054 5 : globalIndexCounter = SgReferenceType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1055 5 : listOfMemoryPoolSizes [ 492 ] = globalIndexCounter;
1056 5 : globalIndexCounter = SgRenamePair::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1057 5 : listOfMemoryPoolSizes [ 493 ] = globalIndexCounter;
1058 5 : globalIndexCounter = SgRenameSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1059 5 : listOfMemoryPoolSizes [ 494 ] = globalIndexCounter;
1060 5 : globalIndexCounter = SgReturnStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1061 5 : listOfMemoryPoolSizes [ 495 ] = globalIndexCounter;
1062 5 : globalIndexCounter = SgRewindStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1063 5 : listOfMemoryPoolSizes [ 496 ] = globalIndexCounter;
1064 5 : globalIndexCounter = SgRshiftAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1065 5 : listOfMemoryPoolSizes [ 497 ] = globalIndexCounter;
1066 5 : globalIndexCounter = SgRshiftOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1067 5 : listOfMemoryPoolSizes [ 498 ] = globalIndexCounter;
1068 5 : globalIndexCounter = SgRvalueReferenceType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1069 5 : listOfMemoryPoolSizes [ 499 ] = globalIndexCounter;
1070 5 : globalIndexCounter = SgScopeOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1071 5 : listOfMemoryPoolSizes [ 500 ] = globalIndexCounter;
1072 5 : globalIndexCounter = SgScopeStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1073 5 : listOfMemoryPoolSizes [ 501 ] = globalIndexCounter;
1074 5 : globalIndexCounter = SgSequenceStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1075 5 : listOfMemoryPoolSizes [ 502 ] = globalIndexCounter;
1076 5 : globalIndexCounter = SgSetComprehension::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1077 5 : listOfMemoryPoolSizes [ 503 ] = globalIndexCounter;
1078 5 : globalIndexCounter = SgShortVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1079 5 : listOfMemoryPoolSizes [ 504 ] = globalIndexCounter;
1080 5 : globalIndexCounter = SgSIMDBinaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1081 5 : listOfMemoryPoolSizes [ 505 ] = globalIndexCounter;
1082 5 : globalIndexCounter = SgSIMDAddOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1083 5 : listOfMemoryPoolSizes [ 506 ] = globalIndexCounter;
1084 5 : globalIndexCounter = SgSIMDSubOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1085 5 : listOfMemoryPoolSizes [ 507 ] = globalIndexCounter;
1086 5 : globalIndexCounter = SgSIMDMulOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1087 5 : listOfMemoryPoolSizes [ 508 ] = globalIndexCounter;
1088 5 : globalIndexCounter = SgSIMDDivOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1089 5 : listOfMemoryPoolSizes [ 509 ] = globalIndexCounter;
1090 5 : globalIndexCounter = SgSIMDFmaOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1091 5 : listOfMemoryPoolSizes [ 510 ] = globalIndexCounter;
1092 5 : globalIndexCounter = SgSIMDLoad::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1093 5 : listOfMemoryPoolSizes [ 511 ] = globalIndexCounter;
1094 5 : globalIndexCounter = SgSIMDBroadcast::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1095 5 : listOfMemoryPoolSizes [ 512 ] = globalIndexCounter;
1096 5 : globalIndexCounter = SgSIMDStore::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1097 5 : listOfMemoryPoolSizes [ 513 ] = globalIndexCounter;
1098 5 : globalIndexCounter = SgSIMDPartialStore::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1099 5 : listOfMemoryPoolSizes [ 514 ] = globalIndexCounter;
1100 5 : globalIndexCounter = SgSIMDScalarStore::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1101 5 : listOfMemoryPoolSizes [ 515 ] = globalIndexCounter;
1102 5 : globalIndexCounter = SgSIMDGather::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1103 5 : listOfMemoryPoolSizes [ 516 ] = globalIndexCounter;
1104 5 : globalIndexCounter = SgSIMDExplicitGather::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1105 5 : listOfMemoryPoolSizes [ 517 ] = globalIndexCounter;
1106 5 : globalIndexCounter = SgSIMDScatter::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1107 5 : listOfMemoryPoolSizes [ 518 ] = globalIndexCounter;
1108 5 : globalIndexCounter = SgSizeOfOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1109 5 : listOfMemoryPoolSizes [ 519 ] = globalIndexCounter;
1110 5 : globalIndexCounter = SgAlignOfOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1111 5 : listOfMemoryPoolSizes [ 520 ] = globalIndexCounter;
1112 5 : globalIndexCounter = SgSourceFile::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1113 5 : listOfMemoryPoolSizes [ 521 ] = globalIndexCounter;
1114 5 : globalIndexCounter = SgSpaceshipOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1115 5 : listOfMemoryPoolSizes [ 522 ] = globalIndexCounter;
1116 5 : globalIndexCounter = SgSpawnStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1117 5 : listOfMemoryPoolSizes [ 523 ] = globalIndexCounter;
1118 5 : globalIndexCounter = SgSyncAllStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1119 5 : listOfMemoryPoolSizes [ 524 ] = globalIndexCounter;
1120 5 : globalIndexCounter = SgSyncImagesStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1121 5 : listOfMemoryPoolSizes [ 525 ] = globalIndexCounter;
1122 5 : globalIndexCounter = SgSyncMemoryStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1123 5 : listOfMemoryPoolSizes [ 526 ] = globalIndexCounter;
1124 5 : globalIndexCounter = SgSyncTeamStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1125 5 : listOfMemoryPoolSizes [ 527 ] = globalIndexCounter;
1126 5 : globalIndexCounter = SgLockStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1127 5 : listOfMemoryPoolSizes [ 528 ] = globalIndexCounter;
1128 5 : globalIndexCounter = SgUnlockStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1129 5 : listOfMemoryPoolSizes [ 529 ] = globalIndexCounter;
1130 5 : globalIndexCounter = SgProcessControlStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1131 5 : listOfMemoryPoolSizes [ 530 ] = globalIndexCounter;
1132 5 : globalIndexCounter = SgSpecialFunctionModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1133 5 : listOfMemoryPoolSizes [ 531 ] = globalIndexCounter;
1134 5 : globalIndexCounter = SgStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1135 5 : listOfMemoryPoolSizes [ 532 ] = globalIndexCounter;
1136 5 : globalIndexCounter = SgStaticAssertionDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1137 5 : listOfMemoryPoolSizes [ 533 ] = globalIndexCounter;
1138 5 : globalIndexCounter = SgStmtDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1139 5 : listOfMemoryPoolSizes [ 534 ] = globalIndexCounter;
1140 5 : globalIndexCounter = SgStatementExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1141 5 : listOfMemoryPoolSizes [ 535 ] = globalIndexCounter;
1142 5 : globalIndexCounter = SgStatementFunctionStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1143 5 : listOfMemoryPoolSizes [ 536 ] = globalIndexCounter;
1144 5 : listOfMemoryPoolSizes [ 537 ] = globalIndexCounter;
1145 5 : globalIndexCounter = SgStorageModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1146 5 : listOfMemoryPoolSizes [ 538 ] = globalIndexCounter;
1147 5 : globalIndexCounter = SgStringConversion::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1148 5 : listOfMemoryPoolSizes [ 539 ] = globalIndexCounter;
1149 5 : globalIndexCounter = SgStringKeyedBidirectionalGraph::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1150 5 : listOfMemoryPoolSizes [ 540 ] = globalIndexCounter;
1151 5 : globalIndexCounter = SgStringVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1152 5 : listOfMemoryPoolSizes [ 541 ] = globalIndexCounter;
1153 5 : globalIndexCounter = SgStructureModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1154 5 : listOfMemoryPoolSizes [ 542 ] = globalIndexCounter;
1155 5 : globalIndexCounter = SgSubscriptExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1156 5 : listOfMemoryPoolSizes [ 543 ] = globalIndexCounter;
1157 5 : globalIndexCounter = SgSubtractOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1158 5 : listOfMemoryPoolSizes [ 544 ] = globalIndexCounter;
1159 5 : globalIndexCounter = SgSupport::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1160 5 : listOfMemoryPoolSizes [ 545 ] = globalIndexCounter;
1161 5 : globalIndexCounter = SgSwitchStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1162 5 : listOfMemoryPoolSizes [ 546 ] = globalIndexCounter;
1163 5 : globalIndexCounter = SgSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1164 5 : listOfMemoryPoolSizes [ 547 ] = globalIndexCounter;
1165 5 : globalIndexCounter = SgSymbolTable::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1166 5 : listOfMemoryPoolSizes [ 548 ] = globalIndexCounter;
1167 5 : globalIndexCounter = SgTemplateArgument::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1168 5 : listOfMemoryPoolSizes [ 549 ] = globalIndexCounter;
1169 5 : globalIndexCounter = SgTemplateArgumentList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1170 5 : listOfMemoryPoolSizes [ 550 ] = globalIndexCounter;
1171 5 : globalIndexCounter = SgTemplateDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1172 5 : listOfMemoryPoolSizes [ 551 ] = globalIndexCounter;
1173 5 : globalIndexCounter = SgTemplateClassDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1174 5 : listOfMemoryPoolSizes [ 552 ] = globalIndexCounter;
1175 5 : globalIndexCounter = SgTemplateClassSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1176 5 : listOfMemoryPoolSizes [ 553 ] = globalIndexCounter;
1177 5 : globalIndexCounter = SgTemplateFunctionDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1178 5 : listOfMemoryPoolSizes [ 554 ] = globalIndexCounter;
1179 5 : globalIndexCounter = SgTemplateFunctionRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1180 5 : listOfMemoryPoolSizes [ 555 ] = globalIndexCounter;
1181 5 : globalIndexCounter = SgTemplateFunctionSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1182 5 : listOfMemoryPoolSizes [ 556 ] = globalIndexCounter;
1183 5 : globalIndexCounter = SgTemplateMemberFunctionDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1184 5 : listOfMemoryPoolSizes [ 557 ] = globalIndexCounter;
1185 5 : globalIndexCounter = SgTemplateMemberFunctionRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1186 5 : listOfMemoryPoolSizes [ 558 ] = globalIndexCounter;
1187 5 : globalIndexCounter = SgTemplateMemberFunctionSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1188 5 : listOfMemoryPoolSizes [ 559 ] = globalIndexCounter;
1189 5 : globalIndexCounter = SgTemplateTypedefDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1190 5 : listOfMemoryPoolSizes [ 560 ] = globalIndexCounter;
1191 5 : globalIndexCounter = SgTemplateTypedefSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1192 5 : listOfMemoryPoolSizes [ 561 ] = globalIndexCounter;
1193 5 : globalIndexCounter = SgTemplateVariableDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1194 5 : listOfMemoryPoolSizes [ 562 ] = globalIndexCounter;
1195 5 : globalIndexCounter = SgTemplateVariableSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1196 5 : listOfMemoryPoolSizes [ 563 ] = globalIndexCounter;
1197 5 : globalIndexCounter = SgTemplateClassDefinition::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1198 5 : listOfMemoryPoolSizes [ 564 ] = globalIndexCounter;
1199 5 : globalIndexCounter = SgTemplateFunctionDefinition::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1200 5 : listOfMemoryPoolSizes [ 565 ] = globalIndexCounter;
1201 5 : globalIndexCounter = SgTemplateInstantiationDecl::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1202 5 : listOfMemoryPoolSizes [ 566 ] = globalIndexCounter;
1203 5 : globalIndexCounter = SgTemplateInstantiationDefn::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1204 5 : listOfMemoryPoolSizes [ 567 ] = globalIndexCounter;
1205 5 : globalIndexCounter = SgTemplateInstantiationDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1206 5 : listOfMemoryPoolSizes [ 568 ] = globalIndexCounter;
1207 5 : globalIndexCounter = SgTemplateInstantiationFunctionDecl::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1208 5 : listOfMemoryPoolSizes [ 569 ] = globalIndexCounter;
1209 5 : globalIndexCounter = SgTemplateInstantiationMemberFunctionDecl::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1210 5 : listOfMemoryPoolSizes [ 570 ] = globalIndexCounter;
1211 5 : globalIndexCounter = SgTemplateInstantiationTypedefDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1212 5 : listOfMemoryPoolSizes [ 571 ] = globalIndexCounter;
1213 5 : globalIndexCounter = SgTemplateParameter::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1214 5 : listOfMemoryPoolSizes [ 572 ] = globalIndexCounter;
1215 5 : globalIndexCounter = SgTemplateParameterVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1216 5 : listOfMemoryPoolSizes [ 573 ] = globalIndexCounter;
1217 5 : globalIndexCounter = SgTemplateParameterList::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1218 5 : listOfMemoryPoolSizes [ 574 ] = globalIndexCounter;
1219 5 : globalIndexCounter = SgTemplateSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1220 5 : listOfMemoryPoolSizes [ 575 ] = globalIndexCounter;
1221 5 : globalIndexCounter = SgTemplateType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1222 5 : listOfMemoryPoolSizes [ 576 ] = globalIndexCounter;
1223 5 : globalIndexCounter = SgThisExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1224 5 : listOfMemoryPoolSizes [ 577 ] = globalIndexCounter;
1225 5 : globalIndexCounter = SgTypeTraitBuiltinOperator::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1226 5 : listOfMemoryPoolSizes [ 578 ] = globalIndexCounter;
1227 5 : globalIndexCounter = SgSuperExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1228 5 : listOfMemoryPoolSizes [ 579 ] = globalIndexCounter;
1229 5 : globalIndexCounter = SgThrowOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1230 5 : listOfMemoryPoolSizes [ 580 ] = globalIndexCounter;
1231 5 : globalIndexCounter = SgToken::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1232 5 : listOfMemoryPoolSizes [ 581 ] = globalIndexCounter;
1233 5 : globalIndexCounter = SgTryStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1234 5 : listOfMemoryPoolSizes [ 582 ] = globalIndexCounter;
1235 5 : globalIndexCounter = SgTupleExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1236 5 : listOfMemoryPoolSizes [ 583 ] = globalIndexCounter;
1237 5 : globalIndexCounter = SgType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1238 5 : listOfMemoryPoolSizes [ 584 ] = globalIndexCounter;
1239 5 : globalIndexCounter = SgTypeBool::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1240 5 : listOfMemoryPoolSizes [ 585 ] = globalIndexCounter;
1241 5 : globalIndexCounter = SgTypeChar::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1242 5 : listOfMemoryPoolSizes [ 586 ] = globalIndexCounter;
1243 5 : globalIndexCounter = SgTypeChar16::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1244 5 : listOfMemoryPoolSizes [ 587 ] = globalIndexCounter;
1245 5 : globalIndexCounter = SgTypeChar32::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1246 5 : listOfMemoryPoolSizes [ 588 ] = globalIndexCounter;
1247 5 : globalIndexCounter = SgTypeComplex::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1248 5 : listOfMemoryPoolSizes [ 589 ] = globalIndexCounter;
1249 5 : globalIndexCounter = SgTypeDefault::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1250 5 : listOfMemoryPoolSizes [ 590 ] = globalIndexCounter;
1251 5 : globalIndexCounter = SgTypeExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1252 5 : listOfMemoryPoolSizes [ 591 ] = globalIndexCounter;
1253 5 : globalIndexCounter = SgTypeLabel::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1254 5 : listOfMemoryPoolSizes [ 592 ] = globalIndexCounter;
1255 5 : globalIndexCounter = SgTypeDouble::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1256 5 : listOfMemoryPoolSizes [ 593 ] = globalIndexCounter;
1257 5 : globalIndexCounter = SgTypeEllipse::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1258 5 : listOfMemoryPoolSizes [ 594 ] = globalIndexCounter;
1259 5 : globalIndexCounter = SgTypeFixed::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1260 5 : listOfMemoryPoolSizes [ 595 ] = globalIndexCounter;
1261 5 : globalIndexCounter = SgTypeFloat::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1262 5 : listOfMemoryPoolSizes [ 596 ] = globalIndexCounter;
1263 5 : globalIndexCounter = SgTypeFloat128::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1264 5 : listOfMemoryPoolSizes [ 597 ] = globalIndexCounter;
1265 5 : globalIndexCounter = SgTypeFloat80::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1266 5 : listOfMemoryPoolSizes [ 598 ] = globalIndexCounter;
1267 5 : globalIndexCounter = SgTypeGlobalVoid::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1268 5 : listOfMemoryPoolSizes [ 599 ] = globalIndexCounter;
1269 5 : globalIndexCounter = SgTypeIdOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1270 5 : listOfMemoryPoolSizes [ 600 ] = globalIndexCounter;
1271 5 : globalIndexCounter = SgTypeImaginary::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1272 5 : listOfMemoryPoolSizes [ 601 ] = globalIndexCounter;
1273 5 : globalIndexCounter = SgTypeInt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1274 5 : listOfMemoryPoolSizes [ 602 ] = globalIndexCounter;
1275 5 : globalIndexCounter = SgTypeLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1276 5 : listOfMemoryPoolSizes [ 603 ] = globalIndexCounter;
1277 5 : globalIndexCounter = SgTypeLongDouble::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1278 5 : listOfMemoryPoolSizes [ 604 ] = globalIndexCounter;
1279 5 : globalIndexCounter = SgTypeLongLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1280 5 : listOfMemoryPoolSizes [ 605 ] = globalIndexCounter;
1281 5 : globalIndexCounter = SgTypeModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1282 5 : listOfMemoryPoolSizes [ 606 ] = globalIndexCounter;
1283 5 : globalIndexCounter = SgTypeMatrix::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1284 5 : listOfMemoryPoolSizes [ 607 ] = globalIndexCounter;
1285 5 : globalIndexCounter = SgTypeTuple::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1286 5 : listOfMemoryPoolSizes [ 608 ] = globalIndexCounter;
1287 5 : globalIndexCounter = SgTypeNullptr::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1288 5 : listOfMemoryPoolSizes [ 609 ] = globalIndexCounter;
1289 5 : globalIndexCounter = SgTypeOfType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1290 5 : listOfMemoryPoolSizes [ 610 ] = globalIndexCounter;
1291 5 : globalIndexCounter = SgTypeShort::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1292 5 : listOfMemoryPoolSizes [ 611 ] = globalIndexCounter;
1293 5 : globalIndexCounter = SgTypeSigned128bitInteger::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1294 5 : listOfMemoryPoolSizes [ 612 ] = globalIndexCounter;
1295 5 : globalIndexCounter = SgTypeSignedChar::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1296 5 : listOfMemoryPoolSizes [ 613 ] = globalIndexCounter;
1297 5 : globalIndexCounter = SgTypeSignedInt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1298 5 : listOfMemoryPoolSizes [ 614 ] = globalIndexCounter;
1299 5 : globalIndexCounter = SgTypeSignedLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1300 5 : listOfMemoryPoolSizes [ 615 ] = globalIndexCounter;
1301 5 : globalIndexCounter = SgTypeSignedLongLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1302 5 : listOfMemoryPoolSizes [ 616 ] = globalIndexCounter;
1303 5 : globalIndexCounter = SgTypeSignedShort::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1304 5 : listOfMemoryPoolSizes [ 617 ] = globalIndexCounter;
1305 5 : globalIndexCounter = SgTypeString::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1306 5 : listOfMemoryPoolSizes [ 618 ] = globalIndexCounter;
1307 5 : globalIndexCounter = SgTypeUnknown::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1308 5 : listOfMemoryPoolSizes [ 619 ] = globalIndexCounter;
1309 5 : globalIndexCounter = SgTypeUnsigned128bitInteger::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1310 5 : listOfMemoryPoolSizes [ 620 ] = globalIndexCounter;
1311 5 : globalIndexCounter = SgTypeUnsignedChar::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1312 5 : listOfMemoryPoolSizes [ 621 ] = globalIndexCounter;
1313 5 : globalIndexCounter = SgTypeUnsignedInt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1314 5 : listOfMemoryPoolSizes [ 622 ] = globalIndexCounter;
1315 5 : globalIndexCounter = SgTypeUnsignedLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1316 5 : listOfMemoryPoolSizes [ 623 ] = globalIndexCounter;
1317 5 : globalIndexCounter = SgTypeUnsignedLongLong::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1318 5 : listOfMemoryPoolSizes [ 624 ] = globalIndexCounter;
1319 5 : globalIndexCounter = SgTypeUnsignedShort::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1320 5 : listOfMemoryPoolSizes [ 625 ] = globalIndexCounter;
1321 5 : globalIndexCounter = SgTypeVoid::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1322 5 : listOfMemoryPoolSizes [ 626 ] = globalIndexCounter;
1323 5 : globalIndexCounter = SgTypeWchar::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1324 5 : listOfMemoryPoolSizes [ 627 ] = globalIndexCounter;
1325 5 : globalIndexCounter = SgTypedefDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1326 5 : listOfMemoryPoolSizes [ 628 ] = globalIndexCounter;
1327 5 : globalIndexCounter = SgTypedefSeq::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1328 5 : listOfMemoryPoolSizes [ 629 ] = globalIndexCounter;
1329 5 : globalIndexCounter = SgTypedefSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1330 5 : listOfMemoryPoolSizes [ 630 ] = globalIndexCounter;
1331 5 : globalIndexCounter = SgTypedefType::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1332 5 : listOfMemoryPoolSizes [ 631 ] = globalIndexCounter;
1333 5 : globalIndexCounter = SgUPC_AccessModifier::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1334 5 : listOfMemoryPoolSizes [ 632 ] = globalIndexCounter;
1335 5 : globalIndexCounter = SgUnaryAddOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1336 5 : listOfMemoryPoolSizes [ 633 ] = globalIndexCounter;
1337 5 : globalIndexCounter = SgUnaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1338 5 : listOfMemoryPoolSizes [ 634 ] = globalIndexCounter;
1339 5 : globalIndexCounter = SgUndefDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1340 5 : listOfMemoryPoolSizes [ 635 ] = globalIndexCounter;
1341 5 : globalIndexCounter = SgUndirectedGraphEdge::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1342 5 : listOfMemoryPoolSizes [ 636 ] = globalIndexCounter;
1343 5 : globalIndexCounter = SgUnknownArrayOrFunctionReference::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1344 5 : listOfMemoryPoolSizes [ 637 ] = globalIndexCounter;
1345 5 : globalIndexCounter = SgUnknownFile::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1346 5 : listOfMemoryPoolSizes [ 638 ] = globalIndexCounter;
1347 5 : listOfMemoryPoolSizes [ 639 ] = globalIndexCounter;
1348 5 : globalIndexCounter = SgUnparse_Info::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1349 5 : listOfMemoryPoolSizes [ 640 ] = globalIndexCounter;
1350 5 : globalIndexCounter = SgUnsignedCharVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1351 5 : listOfMemoryPoolSizes [ 641 ] = globalIndexCounter;
1352 5 : globalIndexCounter = SgUnsignedIntVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1353 5 : listOfMemoryPoolSizes [ 642 ] = globalIndexCounter;
1354 5 : globalIndexCounter = SgUnsignedLongLongIntVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1355 5 : listOfMemoryPoolSizes [ 643 ] = globalIndexCounter;
1356 5 : globalIndexCounter = SgUnsignedLongVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1357 5 : listOfMemoryPoolSizes [ 644 ] = globalIndexCounter;
1358 5 : globalIndexCounter = SgUnsignedShortVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1359 5 : listOfMemoryPoolSizes [ 645 ] = globalIndexCounter;
1360 5 : globalIndexCounter = SgUpcBarrierStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1361 5 : listOfMemoryPoolSizes [ 646 ] = globalIndexCounter;
1362 5 : globalIndexCounter = SgUpcBlocksizeofExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1363 5 : listOfMemoryPoolSizes [ 647 ] = globalIndexCounter;
1364 5 : globalIndexCounter = SgUpcElemsizeofExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1365 5 : listOfMemoryPoolSizes [ 648 ] = globalIndexCounter;
1366 5 : globalIndexCounter = SgUpcFenceStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1367 5 : listOfMemoryPoolSizes [ 649 ] = globalIndexCounter;
1368 5 : globalIndexCounter = SgUpcForAllStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1369 5 : listOfMemoryPoolSizes [ 650 ] = globalIndexCounter;
1370 5 : globalIndexCounter = SgUpcLocalsizeofExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1371 5 : listOfMemoryPoolSizes [ 651 ] = globalIndexCounter;
1372 5 : globalIndexCounter = SgUpcMythread::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1373 5 : listOfMemoryPoolSizes [ 652 ] = globalIndexCounter;
1374 5 : globalIndexCounter = SgUpcNotifyStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1375 5 : listOfMemoryPoolSizes [ 653 ] = globalIndexCounter;
1376 5 : globalIndexCounter = SgUpcThreads::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1377 5 : listOfMemoryPoolSizes [ 654 ] = globalIndexCounter;
1378 5 : globalIndexCounter = SgUpcWaitStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1379 5 : listOfMemoryPoolSizes [ 655 ] = globalIndexCounter;
1380 5 : globalIndexCounter = SgUseStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1381 5 : listOfMemoryPoolSizes [ 656 ] = globalIndexCounter;
1382 5 : globalIndexCounter = SgUserDefinedBinaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1383 5 : listOfMemoryPoolSizes [ 657 ] = globalIndexCounter;
1384 5 : globalIndexCounter = SgUserDefinedUnaryOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1385 5 : listOfMemoryPoolSizes [ 658 ] = globalIndexCounter;
1386 5 : globalIndexCounter = SgUsingDeclarationStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1387 5 : listOfMemoryPoolSizes [ 659 ] = globalIndexCounter;
1388 5 : globalIndexCounter = SgUsingDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1389 5 : listOfMemoryPoolSizes [ 660 ] = globalIndexCounter;
1390 5 : globalIndexCounter = SgValueExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1391 5 : listOfMemoryPoolSizes [ 661 ] = globalIndexCounter;
1392 5 : globalIndexCounter = SgVarArgCopyOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1393 5 : listOfMemoryPoolSizes [ 662 ] = globalIndexCounter;
1394 5 : globalIndexCounter = SgVarArgEndOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1395 5 : listOfMemoryPoolSizes [ 663 ] = globalIndexCounter;
1396 5 : globalIndexCounter = SgVarArgOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1397 5 : listOfMemoryPoolSizes [ 664 ] = globalIndexCounter;
1398 5 : globalIndexCounter = SgVarArgStartOneOperandOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1399 5 : listOfMemoryPoolSizes [ 665 ] = globalIndexCounter;
1400 5 : globalIndexCounter = SgVarArgStartOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1401 5 : listOfMemoryPoolSizes [ 666 ] = globalIndexCounter;
1402 5 : globalIndexCounter = SgVarRefExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1403 5 : listOfMemoryPoolSizes [ 667 ] = globalIndexCounter;
1404 5 : globalIndexCounter = SgVariableDeclaration::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1405 5 : listOfMemoryPoolSizes [ 668 ] = globalIndexCounter;
1406 5 : globalIndexCounter = SgVariableDefinition::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1407 5 : listOfMemoryPoolSizes [ 669 ] = globalIndexCounter;
1408 5 : globalIndexCounter = SgVariableSymbol::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1409 5 : listOfMemoryPoolSizes [ 670 ] = globalIndexCounter;
1410 5 : globalIndexCounter = SgVariantExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1411 5 : listOfMemoryPoolSizes [ 671 ] = globalIndexCounter;
1412 5 : globalIndexCounter = SgVariantStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1413 5 : listOfMemoryPoolSizes [ 672 ] = globalIndexCounter;
1414 5 : globalIndexCounter = SgVoidVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1415 5 : listOfMemoryPoolSizes [ 673 ] = globalIndexCounter;
1416 5 : globalIndexCounter = SgWaitStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1417 5 : listOfMemoryPoolSizes [ 674 ] = globalIndexCounter;
1418 5 : globalIndexCounter = SgWarningDirectiveStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1419 5 : listOfMemoryPoolSizes [ 675 ] = globalIndexCounter;
1420 5 : globalIndexCounter = SgWithStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1421 5 : listOfMemoryPoolSizes [ 676 ] = globalIndexCounter;
1422 5 : globalIndexCounter = SgWcharVal::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1423 5 : listOfMemoryPoolSizes [ 677 ] = globalIndexCounter;
1424 5 : globalIndexCounter = SgWhereStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1425 5 : listOfMemoryPoolSizes [ 678 ] = globalIndexCounter;
1426 5 : globalIndexCounter = SgWhileStmt::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1427 5 : listOfMemoryPoolSizes [ 679 ] = globalIndexCounter;
1428 5 : globalIndexCounter = SgWriteStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1429 5 : listOfMemoryPoolSizes [ 680 ] = globalIndexCounter;
1430 5 : globalIndexCounter = SgXorAssignOp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1431 5 : listOfMemoryPoolSizes [ 681 ] = globalIndexCounter;
1432 5 : globalIndexCounter = SgYieldExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1433 5 : listOfMemoryPoolSizes [ 682 ] = globalIndexCounter;
1434 5 : globalIndexCounter = Sg_File_Info::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1435 5 : listOfMemoryPoolSizes [ 683 ] = globalIndexCounter;
1436 5 : globalIndexCounter = SgTypeCAFTeam::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1437 5 : listOfMemoryPoolSizes [ 684 ] = globalIndexCounter;
1438 5 : globalIndexCounter = SgCAFWithTeamStatement::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1439 5 : listOfMemoryPoolSizes [ 685 ] = globalIndexCounter;
1440 5 : globalIndexCounter = SgCAFCoExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1441 5 : listOfMemoryPoolSizes [ 686 ] = globalIndexCounter;
1442 5 : globalIndexCounter = SgCallExpression::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1443 5 : listOfMemoryPoolSizes [ 687 ] = globalIndexCounter;
1444 5 : globalIndexCounter = SgTypeCrayPointer::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1445 5 : listOfMemoryPoolSizes [ 688 ] = globalIndexCounter;
1446 5 : globalIndexCounter = SgClassExp::getNumberOfValidNodesAndSetGlobalIndexInFreepointer ( globalIndexCounter ) ;
1447 5 : listOfMemoryPoolSizes [ 689 ] = globalIndexCounter;
1448 5 : listOfMemoryPoolSizes [ 690 ] = globalIndexCounter;
1449 :
1450 : /* #line 78 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
1451 :
1452 : #if DEBUG_AstFileIO_startUp
1453 : std::cout << "listOfMemoryPoolSizes [935] = " << std::dec << listOfMemoryPoolSizes [935] << std::endl;
1454 : #endif
1455 :
1456 5 : {
1457 : // DQ (4/22/2006): Added timer information for AST File I/O
1458 5 : TimingPerformance nested_timer ("AST_FILE_IO::startUp() Build contiguious storage:");
1459 :
1460 5 : actualRebuildAst = new AstData(root);
1461 5 : vectorOfASTs.push_back( actualRebuildAst );
1462 :
1463 5 : actualRebuildAst->listOfAccumulatedPoolSizes[0] = listOfMemoryPoolSizes[0];
1464 3455 : for (int i = 0; i < totalNumberOfIRNodes ; ++i )
1465 : {
1466 3450 : actualRebuildAst->listOfAccumulatedPoolSizes[i+1] = listOfMemoryPoolSizes[i+1];
1467 3450 : listOfMemoryPoolSizes[i] = actualRebuildAst->listOfAccumulatedPoolSizes[i+1] - actualRebuildAst->listOfAccumulatedPoolSizes[i];
1468 : }
1469 :
1470 5 : freepointersOfCurrentAstAreSetToGlobalIndices = true;
1471 :
1472 5 : REGISTER_ATTRIBUTE_FOR_FILE_IO(AstAttribute) ;
1473 : }
1474 :
1475 5 : }
1476 :
1477 :
1478 : unsigned long
1479 1742990 : AST_FILE_IO :: getSizeOfMemoryPool( const int position )
1480 : {
1481 : /* JH (01/03/2006): method returns the accumulated pool sizes of the pools that are
1482 : previous to V_position -> i.e. the SgVariant of an IRNode class
1483 : */
1484 1742990 : return listOfMemoryPoolSizes [ position ];
1485 : }
1486 :
1487 :
1488 : unsigned long
1489 0 : AST_FILE_IO :: getSizeOfMemoryPoolUpToAst( AstData *astInPool, const int position )
1490 : {
1491 : /* JH (01/03/2006): method returns the accumulated pool sizes of the pools that are
1492 : previous to V_position -> i.e. the SgVariant of an IRNode class
1493 : */
1494 0 : unsigned long memoryPoolSize = 0;
1495 0 : for (int i=0;i < astInPool->get_AstIndex(); ++i)
1496 : {
1497 0 : memoryPoolSize += vectorOfASTs[i]->getMemoryPoolSize(position);
1498 : }
1499 0 : return memoryPoolSize;
1500 : }
1501 :
1502 : unsigned long
1503 8697950 : AST_FILE_IO :: getAccumulatedPoolSizeOfNewAst( const int position )
1504 : {
1505 : /* JH (01/03/2006): method returns the accumulated pool sizes of the pools that are
1506 : previous to V_position -> i.e. the SgVariant of an IRNode class
1507 : */
1508 8697950 : return actualRebuildAst->getNumberOfAccumulatedNodes ( position ) ;
1509 : }
1510 :
1511 :
1512 : unsigned long
1513 0 : AST_FILE_IO :: getAccumulatedPoolSizeOfAst( AstData *astInPool, const int position )
1514 : {
1515 : /* JH (01/03/2006): method returns the accumulated pool sizes of the pools that are
1516 : previous to V_position -> i.e. the SgVariant of an IRNode class
1517 : */
1518 0 : return astInPool->getNumberOfAccumulatedNodes ( position ) ;
1519 : }
1520 :
1521 :
1522 : unsigned long
1523 4098 : AST_FILE_IO :: getPoolSizeOfNewAst( const int position )
1524 : {
1525 : /* JH (01/03/2006): method returns the accumulated pool sizes of the pools that are
1526 : previous to V_position -> i.e. the SgVariant of an IRNode class
1527 : */
1528 4098 : return actualRebuildAst->getMemoryPoolSize ( position ) ;
1529 : }
1530 :
1531 :
1532 : unsigned long
1533 1739590 : AST_FILE_IO :: getTotalNumberOfNodesOfAstInMemoryPool ( )
1534 : {
1535 : // JH (01/03/2006): returning the sum of all pool sizes; this is used for checking only ...
1536 1739590 : return listOfMemoryPoolSizes [ totalNumberOfIRNodes ] ;
1537 : }
1538 :
1539 :
1540 : unsigned long
1541 1739590 : AST_FILE_IO :: getTotalNumberOfNodesOfNewAst ( )
1542 : {
1543 : // JH (01/03/2006): returning the sum of all pool sizes; this is used for checking only ...
1544 1739590 : assert (actualRebuildAst != NULL);
1545 1739590 : return actualRebuildAst->getTotalNumberOfASTIRNodes();
1546 : }
1547 :
1548 :
1549 :
1550 : unsigned long
1551 0 : AST_FILE_IO :: linearSearch( unsigned long globalIndex )
1552 : {
1553 : /* JH (01/03/2006): linearSearch. This easy implementation just looks at the first index, where the
1554 : getAccumulated pool sizes exceed index.
1555 : */
1556 : #if FILE_IO_EXTRA_CHECK
1557 : // assert ( 0 <= globalIndex ) ;
1558 0 : assert ( globalIndex < actualRebuildAst->getTotalNumberOfASTIRNodes() ) ;
1559 : #endif
1560 0 : unsigned int actualIRNodeType = 1;
1561 0 : while ( actualIRNodeType < actualRebuildAst->getTotalNumberOfASTIRNodes() )
1562 : {
1563 0 : if ( actualRebuildAst->getNumberOfAccumulatedNodes (actualIRNodeType) <= globalIndex && globalIndex < actualRebuildAst->getNumberOfAccumulatedNodes (actualIRNodeType + 1 ) )
1564 : {
1565 : break ;
1566 : }
1567 : }
1568 : #if FILE_IO_EXTRA_CHECK
1569 0 : assert ( 0 < actualIRNodeType ) ;
1570 0 : assert ( actualIRNodeType < actualRebuildAst->getTotalNumberOfASTIRNodes() ) ;
1571 : #endif
1572 0 : return actualIRNodeType;
1573 : }
1574 :
1575 :
1576 :
1577 : unsigned long
1578 1739590 : AST_FILE_IO :: binarySearch( unsigned long globalIndex, int start , int end )
1579 : {
1580 : /* JH (01/03/2006): binarySearch: find the SgVariant that corresponds to the index contained in
1581 : the pointer. Therefore, we use the accumulatedPoolSizesOfNewAst and check the ranges
1582 : */
1583 18365200 : if ( end - start <= 1 )
1584 : {
1585 1739590 : if ( actualRebuildAst->getNumberOfAccumulatedNodes (start) <= globalIndex && globalIndex < actualRebuildAst->getNumberOfAccumulatedNodes (end) )
1586 : {
1587 1739590 : return start;
1588 : }
1589 : else
1590 : {
1591 0 : return end;
1592 : }
1593 : }
1594 16625600 : int middle = ( end + start ) / 2 ;
1595 16625600 : if ( actualRebuildAst->getNumberOfAccumulatedNodes (middle ) <= globalIndex )
1596 : {
1597 : return binarySearch ( globalIndex , middle , end ) ;
1598 : }
1599 : else
1600 : {
1601 6924860 : return binarySearch ( globalIndex, start , middle ) ;
1602 : }
1603 : }
1604 :
1605 : void
1606 0 : AST_FILE_IO :: compressAstInMemoryPool ( )
1607 : {
1608 : // DQ (4/22/2006): Added timer information for AST File I/O
1609 0 : TimingPerformance timer ("AST_FILE_IO::compressAstInMemoryPool():");
1610 :
1611 0 : assert ( freepointersOfCurrentAstAreSetToGlobalIndices == true );
1612 0 : assert ( 0 < getTotalNumberOfNodesOfAstInMemoryPool() );
1613 : /* JH (01/03/2006): prepareMemoryPoolWise: method that traverses the storage pools.
1614 : 1. For each IRNodesStorageClass the pickOutIRNodeData is called
1615 : 2. The static data of the EasyStorage classes is arranged, in order that all static data (of a type) is
1616 : contained in one memory block
1617 : 3. For each IRNodesStorageClass the rebuildIRNode is called
1618 : 4. The static data of the EasyStorage classes is deleted
1619 : */
1620 :
1621 0 : unsigned long sizeOfActualPool = 0 ;
1622 :
1623 0 : AstSpecificDataManagingClassStorageClass staticTemp;
1624 0 : staticTemp.pickOutIRNodeData(actualRebuildAst);
1625 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAccessModifier ) ;
1626 0 : std::cout << " SgAccessModifier has size " << sizeOfActualPool << std::endl;
1627 0 : SgAccessModifierStorageClass* SgAccessModifierStorageArray = NULL;
1628 0 : if ( 0 < sizeOfActualPool )
1629 : {
1630 0 : SgAccessModifierStorageArray = new SgAccessModifierStorageClass[sizeOfActualPool] ;
1631 0 : unsigned long storageClassIndex = SgAccessModifier::initializeStorageClassArray (SgAccessModifierStorageArray); ;
1632 0 : assert ( storageClassIndex == sizeOfActualPool );
1633 : }
1634 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgActualArgumentExpression ) ;
1635 0 : std::cout << " SgActualArgumentExpression has size " << sizeOfActualPool << std::endl;
1636 0 : SgActualArgumentExpressionStorageClass* SgActualArgumentExpressionStorageArray = NULL;
1637 0 : if ( 0 < sizeOfActualPool )
1638 : {
1639 0 : SgActualArgumentExpressionStorageArray = new SgActualArgumentExpressionStorageClass[sizeOfActualPool] ;
1640 0 : unsigned long storageClassIndex = SgActualArgumentExpression::initializeStorageClassArray (SgActualArgumentExpressionStorageArray); ;
1641 0 : assert ( storageClassIndex == sizeOfActualPool );
1642 : }
1643 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAddOp ) ;
1644 0 : std::cout << " SgAddOp has size " << sizeOfActualPool << std::endl;
1645 0 : SgAddOpStorageClass* SgAddOpStorageArray = NULL;
1646 0 : if ( 0 < sizeOfActualPool )
1647 : {
1648 0 : SgAddOpStorageArray = new SgAddOpStorageClass[sizeOfActualPool] ;
1649 0 : unsigned long storageClassIndex = SgAddOp::initializeStorageClassArray (SgAddOpStorageArray); ;
1650 0 : assert ( storageClassIndex == sizeOfActualPool );
1651 : }
1652 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAddressOfOp ) ;
1653 0 : std::cout << " SgAddressOfOp has size " << sizeOfActualPool << std::endl;
1654 0 : SgAddressOfOpStorageClass* SgAddressOfOpStorageArray = NULL;
1655 0 : if ( 0 < sizeOfActualPool )
1656 : {
1657 0 : SgAddressOfOpStorageArray = new SgAddressOfOpStorageClass[sizeOfActualPool] ;
1658 0 : unsigned long storageClassIndex = SgAddressOfOp::initializeStorageClassArray (SgAddressOfOpStorageArray); ;
1659 0 : assert ( storageClassIndex == sizeOfActualPool );
1660 : }
1661 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAggregateInitializer ) ;
1662 0 : std::cout << " SgAggregateInitializer has size " << sizeOfActualPool << std::endl;
1663 0 : SgAggregateInitializerStorageClass* SgAggregateInitializerStorageArray = NULL;
1664 0 : if ( 0 < sizeOfActualPool )
1665 : {
1666 0 : SgAggregateInitializerStorageArray = new SgAggregateInitializerStorageClass[sizeOfActualPool] ;
1667 0 : unsigned long storageClassIndex = SgAggregateInitializer::initializeStorageClassArray (SgAggregateInitializerStorageArray); ;
1668 0 : assert ( storageClassIndex == sizeOfActualPool );
1669 : }
1670 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAliasSymbol ) ;
1671 0 : std::cout << " SgAliasSymbol has size " << sizeOfActualPool << std::endl;
1672 0 : SgAliasSymbolStorageClass* SgAliasSymbolStorageArray = NULL;
1673 0 : if ( 0 < sizeOfActualPool )
1674 : {
1675 0 : SgAliasSymbolStorageArray = new SgAliasSymbolStorageClass[sizeOfActualPool] ;
1676 0 : unsigned long storageClassIndex = SgAliasSymbol::initializeStorageClassArray (SgAliasSymbolStorageArray); ;
1677 0 : assert ( storageClassIndex == sizeOfActualPool );
1678 : }
1679 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAllocateStatement ) ;
1680 0 : std::cout << " SgAllocateStatement has size " << sizeOfActualPool << std::endl;
1681 0 : SgAllocateStatementStorageClass* SgAllocateStatementStorageArray = NULL;
1682 0 : if ( 0 < sizeOfActualPool )
1683 : {
1684 0 : SgAllocateStatementStorageArray = new SgAllocateStatementStorageClass[sizeOfActualPool] ;
1685 0 : unsigned long storageClassIndex = SgAllocateStatement::initializeStorageClassArray (SgAllocateStatementStorageArray); ;
1686 0 : assert ( storageClassIndex == sizeOfActualPool );
1687 : }
1688 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAndAssignOp ) ;
1689 0 : std::cout << " SgAndAssignOp has size " << sizeOfActualPool << std::endl;
1690 0 : SgAndAssignOpStorageClass* SgAndAssignOpStorageArray = NULL;
1691 0 : if ( 0 < sizeOfActualPool )
1692 : {
1693 0 : SgAndAssignOpStorageArray = new SgAndAssignOpStorageClass[sizeOfActualPool] ;
1694 0 : unsigned long storageClassIndex = SgAndAssignOp::initializeStorageClassArray (SgAndAssignOpStorageArray); ;
1695 0 : assert ( storageClassIndex == sizeOfActualPool );
1696 : }
1697 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAndOp ) ;
1698 0 : std::cout << " SgAndOp has size " << sizeOfActualPool << std::endl;
1699 0 : SgAndOpStorageClass* SgAndOpStorageArray = NULL;
1700 0 : if ( 0 < sizeOfActualPool )
1701 : {
1702 0 : SgAndOpStorageArray = new SgAndOpStorageClass[sizeOfActualPool] ;
1703 0 : unsigned long storageClassIndex = SgAndOp::initializeStorageClassArray (SgAndOpStorageArray); ;
1704 0 : assert ( storageClassIndex == sizeOfActualPool );
1705 : }
1706 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgArithmeticIfStatement ) ;
1707 0 : std::cout << " SgArithmeticIfStatement has size " << sizeOfActualPool << std::endl;
1708 0 : SgArithmeticIfStatementStorageClass* SgArithmeticIfStatementStorageArray = NULL;
1709 0 : if ( 0 < sizeOfActualPool )
1710 : {
1711 0 : SgArithmeticIfStatementStorageArray = new SgArithmeticIfStatementStorageClass[sizeOfActualPool] ;
1712 0 : unsigned long storageClassIndex = SgArithmeticIfStatement::initializeStorageClassArray (SgArithmeticIfStatementStorageArray); ;
1713 0 : assert ( storageClassIndex == sizeOfActualPool );
1714 : }
1715 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgArrayType ) ;
1716 0 : std::cout << " SgArrayType has size " << sizeOfActualPool << std::endl;
1717 0 : SgArrayTypeStorageClass* SgArrayTypeStorageArray = NULL;
1718 0 : if ( 0 < sizeOfActualPool )
1719 : {
1720 0 : SgArrayTypeStorageArray = new SgArrayTypeStorageClass[sizeOfActualPool] ;
1721 0 : unsigned long storageClassIndex = SgArrayType::initializeStorageClassArray (SgArrayTypeStorageArray); ;
1722 0 : assert ( storageClassIndex == sizeOfActualPool );
1723 : }
1724 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgArrowExp ) ;
1725 0 : std::cout << " SgArrowExp has size " << sizeOfActualPool << std::endl;
1726 0 : SgArrowExpStorageClass* SgArrowExpStorageArray = NULL;
1727 0 : if ( 0 < sizeOfActualPool )
1728 : {
1729 0 : SgArrowExpStorageArray = new SgArrowExpStorageClass[sizeOfActualPool] ;
1730 0 : unsigned long storageClassIndex = SgArrowExp::initializeStorageClassArray (SgArrowExpStorageArray); ;
1731 0 : assert ( storageClassIndex == sizeOfActualPool );
1732 : }
1733 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgArrowStarOp ) ;
1734 0 : std::cout << " SgArrowStarOp has size " << sizeOfActualPool << std::endl;
1735 0 : SgArrowStarOpStorageClass* SgArrowStarOpStorageArray = NULL;
1736 0 : if ( 0 < sizeOfActualPool )
1737 : {
1738 0 : SgArrowStarOpStorageArray = new SgArrowStarOpStorageClass[sizeOfActualPool] ;
1739 0 : unsigned long storageClassIndex = SgArrowStarOp::initializeStorageClassArray (SgArrowStarOpStorageArray); ;
1740 0 : assert ( storageClassIndex == sizeOfActualPool );
1741 : }
1742 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAsmOp ) ;
1743 0 : std::cout << " SgAsmOp has size " << sizeOfActualPool << std::endl;
1744 0 : SgAsmOpStorageClass* SgAsmOpStorageArray = NULL;
1745 0 : if ( 0 < sizeOfActualPool )
1746 : {
1747 0 : SgAsmOpStorageArray = new SgAsmOpStorageClass[sizeOfActualPool] ;
1748 0 : unsigned long storageClassIndex = SgAsmOp::initializeStorageClassArray (SgAsmOpStorageArray); ;
1749 0 : assert ( storageClassIndex == sizeOfActualPool );
1750 : }
1751 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAsmStmt ) ;
1752 0 : std::cout << " SgAsmStmt has size " << sizeOfActualPool << std::endl;
1753 0 : SgAsmStmtStorageClass* SgAsmStmtStorageArray = NULL;
1754 0 : if ( 0 < sizeOfActualPool )
1755 : {
1756 0 : SgAsmStmtStorageArray = new SgAsmStmtStorageClass[sizeOfActualPool] ;
1757 0 : unsigned long storageClassIndex = SgAsmStmt::initializeStorageClassArray (SgAsmStmtStorageArray); ;
1758 0 : assert ( storageClassIndex == sizeOfActualPool );
1759 : }
1760 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssertStmt ) ;
1761 0 : std::cout << " SgAssertStmt has size " << sizeOfActualPool << std::endl;
1762 0 : SgAssertStmtStorageClass* SgAssertStmtStorageArray = NULL;
1763 0 : if ( 0 < sizeOfActualPool )
1764 : {
1765 0 : SgAssertStmtStorageArray = new SgAssertStmtStorageClass[sizeOfActualPool] ;
1766 0 : unsigned long storageClassIndex = SgAssertStmt::initializeStorageClassArray (SgAssertStmtStorageArray); ;
1767 0 : assert ( storageClassIndex == sizeOfActualPool );
1768 : }
1769 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssignInitializer ) ;
1770 0 : std::cout << " SgAssignInitializer has size " << sizeOfActualPool << std::endl;
1771 0 : SgAssignInitializerStorageClass* SgAssignInitializerStorageArray = NULL;
1772 0 : if ( 0 < sizeOfActualPool )
1773 : {
1774 0 : SgAssignInitializerStorageArray = new SgAssignInitializerStorageClass[sizeOfActualPool] ;
1775 0 : unsigned long storageClassIndex = SgAssignInitializer::initializeStorageClassArray (SgAssignInitializerStorageArray); ;
1776 0 : assert ( storageClassIndex == sizeOfActualPool );
1777 : }
1778 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssignOp ) ;
1779 0 : std::cout << " SgAssignOp has size " << sizeOfActualPool << std::endl;
1780 0 : SgAssignOpStorageClass* SgAssignOpStorageArray = NULL;
1781 0 : if ( 0 < sizeOfActualPool )
1782 : {
1783 0 : SgAssignOpStorageArray = new SgAssignOpStorageClass[sizeOfActualPool] ;
1784 0 : unsigned long storageClassIndex = SgAssignOp::initializeStorageClassArray (SgAssignOpStorageArray); ;
1785 0 : assert ( storageClassIndex == sizeOfActualPool );
1786 : }
1787 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssignStatement ) ;
1788 0 : std::cout << " SgAssignStatement has size " << sizeOfActualPool << std::endl;
1789 0 : SgAssignStatementStorageClass* SgAssignStatementStorageArray = NULL;
1790 0 : if ( 0 < sizeOfActualPool )
1791 : {
1792 0 : SgAssignStatementStorageArray = new SgAssignStatementStorageClass[sizeOfActualPool] ;
1793 0 : unsigned long storageClassIndex = SgAssignStatement::initializeStorageClassArray (SgAssignStatementStorageArray); ;
1794 0 : assert ( storageClassIndex == sizeOfActualPool );
1795 : }
1796 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssignedGotoStatement ) ;
1797 0 : std::cout << " SgAssignedGotoStatement has size " << sizeOfActualPool << std::endl;
1798 0 : SgAssignedGotoStatementStorageClass* SgAssignedGotoStatementStorageArray = NULL;
1799 0 : if ( 0 < sizeOfActualPool )
1800 : {
1801 0 : SgAssignedGotoStatementStorageArray = new SgAssignedGotoStatementStorageClass[sizeOfActualPool] ;
1802 0 : unsigned long storageClassIndex = SgAssignedGotoStatement::initializeStorageClassArray (SgAssignedGotoStatementStorageArray); ;
1803 0 : assert ( storageClassIndex == sizeOfActualPool );
1804 : }
1805 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAssociateStatement ) ;
1806 0 : std::cout << " SgAssociateStatement has size " << sizeOfActualPool << std::endl;
1807 0 : SgAssociateStatementStorageClass* SgAssociateStatementStorageArray = NULL;
1808 0 : if ( 0 < sizeOfActualPool )
1809 : {
1810 0 : SgAssociateStatementStorageArray = new SgAssociateStatementStorageClass[sizeOfActualPool] ;
1811 0 : unsigned long storageClassIndex = SgAssociateStatement::initializeStorageClassArray (SgAssociateStatementStorageArray); ;
1812 0 : assert ( storageClassIndex == sizeOfActualPool );
1813 : }
1814 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAsteriskShapeExp ) ;
1815 0 : std::cout << " SgAsteriskShapeExp has size " << sizeOfActualPool << std::endl;
1816 0 : SgAsteriskShapeExpStorageClass* SgAsteriskShapeExpStorageArray = NULL;
1817 0 : if ( 0 < sizeOfActualPool )
1818 : {
1819 0 : SgAsteriskShapeExpStorageArray = new SgAsteriskShapeExpStorageClass[sizeOfActualPool] ;
1820 0 : unsigned long storageClassIndex = SgAsteriskShapeExp::initializeStorageClassArray (SgAsteriskShapeExpStorageArray); ;
1821 0 : assert ( storageClassIndex == sizeOfActualPool );
1822 : }
1823 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAttribute ) ;
1824 0 : std::cout << " SgAttribute has size " << sizeOfActualPool << std::endl;
1825 0 : SgAttributeStorageClass* SgAttributeStorageArray = NULL;
1826 0 : if ( 0 < sizeOfActualPool )
1827 : {
1828 0 : SgAttributeStorageArray = new SgAttributeStorageClass[sizeOfActualPool] ;
1829 0 : unsigned long storageClassIndex = SgAttribute::initializeStorageClassArray (SgAttributeStorageArray); ;
1830 0 : assert ( storageClassIndex == sizeOfActualPool );
1831 : }
1832 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAttributeSpecificationStatement ) ;
1833 0 : std::cout << " SgAttributeSpecificationStatement has size " << sizeOfActualPool << std::endl;
1834 0 : SgAttributeSpecificationStatementStorageClass* SgAttributeSpecificationStatementStorageArray = NULL;
1835 0 : if ( 0 < sizeOfActualPool )
1836 : {
1837 0 : SgAttributeSpecificationStatementStorageArray = new SgAttributeSpecificationStatementStorageClass[sizeOfActualPool] ;
1838 0 : unsigned long storageClassIndex = SgAttributeSpecificationStatement::initializeStorageClassArray (SgAttributeSpecificationStatementStorageArray); ;
1839 0 : assert ( storageClassIndex == sizeOfActualPool );
1840 : }
1841 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAutoType ) ;
1842 0 : std::cout << " SgAutoType has size " << sizeOfActualPool << std::endl;
1843 0 : SgAutoTypeStorageClass* SgAutoTypeStorageArray = NULL;
1844 0 : if ( 0 < sizeOfActualPool )
1845 : {
1846 0 : SgAutoTypeStorageArray = new SgAutoTypeStorageClass[sizeOfActualPool] ;
1847 0 : unsigned long storageClassIndex = SgAutoType::initializeStorageClassArray (SgAutoTypeStorageArray); ;
1848 0 : assert ( storageClassIndex == sizeOfActualPool );
1849 : }
1850 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAwaitExpression ) ;
1851 0 : std::cout << " SgAwaitExpression has size " << sizeOfActualPool << std::endl;
1852 0 : SgAwaitExpressionStorageClass* SgAwaitExpressionStorageArray = NULL;
1853 0 : if ( 0 < sizeOfActualPool )
1854 : {
1855 0 : SgAwaitExpressionStorageArray = new SgAwaitExpressionStorageClass[sizeOfActualPool] ;
1856 0 : unsigned long storageClassIndex = SgAwaitExpression::initializeStorageClassArray (SgAwaitExpressionStorageArray); ;
1857 0 : assert ( storageClassIndex == sizeOfActualPool );
1858 : }
1859 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBackspaceStatement ) ;
1860 0 : std::cout << " SgBackspaceStatement has size " << sizeOfActualPool << std::endl;
1861 0 : SgBackspaceStatementStorageClass* SgBackspaceStatementStorageArray = NULL;
1862 0 : if ( 0 < sizeOfActualPool )
1863 : {
1864 0 : SgBackspaceStatementStorageArray = new SgBackspaceStatementStorageClass[sizeOfActualPool] ;
1865 0 : unsigned long storageClassIndex = SgBackspaceStatement::initializeStorageClassArray (SgBackspaceStatementStorageArray); ;
1866 0 : assert ( storageClassIndex == sizeOfActualPool );
1867 : }
1868 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBaseClass ) ;
1869 0 : std::cout << " SgBaseClass has size " << sizeOfActualPool << std::endl;
1870 0 : SgBaseClassStorageClass* SgBaseClassStorageArray = NULL;
1871 0 : if ( 0 < sizeOfActualPool )
1872 : {
1873 0 : SgBaseClassStorageArray = new SgBaseClassStorageClass[sizeOfActualPool] ;
1874 0 : unsigned long storageClassIndex = SgBaseClass::initializeStorageClassArray (SgBaseClassStorageArray); ;
1875 0 : assert ( storageClassIndex == sizeOfActualPool );
1876 : }
1877 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExpBaseClass ) ;
1878 0 : std::cout << " SgExpBaseClass has size " << sizeOfActualPool << std::endl;
1879 0 : SgExpBaseClassStorageClass* SgExpBaseClassStorageArray = NULL;
1880 0 : if ( 0 < sizeOfActualPool )
1881 : {
1882 0 : SgExpBaseClassStorageArray = new SgExpBaseClassStorageClass[sizeOfActualPool] ;
1883 0 : unsigned long storageClassIndex = SgExpBaseClass::initializeStorageClassArray (SgExpBaseClassStorageArray); ;
1884 0 : assert ( storageClassIndex == sizeOfActualPool );
1885 : }
1886 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBaseClassModifier ) ;
1887 0 : std::cout << " SgBaseClassModifier has size " << sizeOfActualPool << std::endl;
1888 0 : SgBaseClassModifierStorageClass* SgBaseClassModifierStorageArray = NULL;
1889 0 : if ( 0 < sizeOfActualPool )
1890 : {
1891 0 : SgBaseClassModifierStorageArray = new SgBaseClassModifierStorageClass[sizeOfActualPool] ;
1892 0 : unsigned long storageClassIndex = SgBaseClassModifier::initializeStorageClassArray (SgBaseClassModifierStorageArray); ;
1893 0 : assert ( storageClassIndex == sizeOfActualPool );
1894 : }
1895 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBasicBlock ) ;
1896 0 : std::cout << " SgBasicBlock has size " << sizeOfActualPool << std::endl;
1897 0 : SgBasicBlockStorageClass* SgBasicBlockStorageArray = NULL;
1898 0 : if ( 0 < sizeOfActualPool )
1899 : {
1900 0 : SgBasicBlockStorageArray = new SgBasicBlockStorageClass[sizeOfActualPool] ;
1901 0 : unsigned long storageClassIndex = SgBasicBlock::initializeStorageClassArray (SgBasicBlockStorageArray); ;
1902 0 : assert ( storageClassIndex == sizeOfActualPool );
1903 : }
1904 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBidirectionalGraph ) ;
1905 0 : std::cout << " SgBidirectionalGraph has size " << sizeOfActualPool << std::endl;
1906 0 : SgBidirectionalGraphStorageClass* SgBidirectionalGraphStorageArray = NULL;
1907 0 : if ( 0 < sizeOfActualPool )
1908 : {
1909 0 : SgBidirectionalGraphStorageArray = new SgBidirectionalGraphStorageClass[sizeOfActualPool] ;
1910 0 : unsigned long storageClassIndex = SgBidirectionalGraph::initializeStorageClassArray (SgBidirectionalGraphStorageArray); ;
1911 0 : assert ( storageClassIndex == sizeOfActualPool );
1912 : }
1913 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBinaryOp ) ;
1914 0 : std::cout << " SgBinaryOp has size " << sizeOfActualPool << std::endl;
1915 0 : SgBinaryOpStorageClass* SgBinaryOpStorageArray = NULL;
1916 0 : if ( 0 < sizeOfActualPool )
1917 : {
1918 0 : SgBinaryOpStorageArray = new SgBinaryOpStorageClass[sizeOfActualPool] ;
1919 0 : unsigned long storageClassIndex = SgBinaryOp::initializeStorageClassArray (SgBinaryOpStorageArray); ;
1920 0 : assert ( storageClassIndex == sizeOfActualPool );
1921 : }
1922 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitAndOp ) ;
1923 0 : std::cout << " SgBitAndOp has size " << sizeOfActualPool << std::endl;
1924 0 : SgBitAndOpStorageClass* SgBitAndOpStorageArray = NULL;
1925 0 : if ( 0 < sizeOfActualPool )
1926 : {
1927 0 : SgBitAndOpStorageArray = new SgBitAndOpStorageClass[sizeOfActualPool] ;
1928 0 : unsigned long storageClassIndex = SgBitAndOp::initializeStorageClassArray (SgBitAndOpStorageArray); ;
1929 0 : assert ( storageClassIndex == sizeOfActualPool );
1930 : }
1931 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitAttribute ) ;
1932 0 : std::cout << " SgBitAttribute has size " << sizeOfActualPool << std::endl;
1933 0 : SgBitAttributeStorageClass* SgBitAttributeStorageArray = NULL;
1934 0 : if ( 0 < sizeOfActualPool )
1935 : {
1936 0 : SgBitAttributeStorageArray = new SgBitAttributeStorageClass[sizeOfActualPool] ;
1937 0 : unsigned long storageClassIndex = SgBitAttribute::initializeStorageClassArray (SgBitAttributeStorageArray); ;
1938 0 : assert ( storageClassIndex == sizeOfActualPool );
1939 : }
1940 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitComplementOp ) ;
1941 0 : std::cout << " SgBitComplementOp has size " << sizeOfActualPool << std::endl;
1942 0 : SgBitComplementOpStorageClass* SgBitComplementOpStorageArray = NULL;
1943 0 : if ( 0 < sizeOfActualPool )
1944 : {
1945 0 : SgBitComplementOpStorageArray = new SgBitComplementOpStorageClass[sizeOfActualPool] ;
1946 0 : unsigned long storageClassIndex = SgBitComplementOp::initializeStorageClassArray (SgBitComplementOpStorageArray); ;
1947 0 : assert ( storageClassIndex == sizeOfActualPool );
1948 : }
1949 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitEqvOp ) ;
1950 0 : std::cout << " SgBitEqvOp has size " << sizeOfActualPool << std::endl;
1951 0 : SgBitEqvOpStorageClass* SgBitEqvOpStorageArray = NULL;
1952 0 : if ( 0 < sizeOfActualPool )
1953 : {
1954 0 : SgBitEqvOpStorageArray = new SgBitEqvOpStorageClass[sizeOfActualPool] ;
1955 0 : unsigned long storageClassIndex = SgBitEqvOp::initializeStorageClassArray (SgBitEqvOpStorageArray); ;
1956 0 : assert ( storageClassIndex == sizeOfActualPool );
1957 : }
1958 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitOrOp ) ;
1959 0 : std::cout << " SgBitOrOp has size " << sizeOfActualPool << std::endl;
1960 0 : SgBitOrOpStorageClass* SgBitOrOpStorageArray = NULL;
1961 0 : if ( 0 < sizeOfActualPool )
1962 : {
1963 0 : SgBitOrOpStorageArray = new SgBitOrOpStorageClass[sizeOfActualPool] ;
1964 0 : unsigned long storageClassIndex = SgBitOrOp::initializeStorageClassArray (SgBitOrOpStorageArray); ;
1965 0 : assert ( storageClassIndex == sizeOfActualPool );
1966 : }
1967 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBitXorOp ) ;
1968 0 : std::cout << " SgBitXorOp has size " << sizeOfActualPool << std::endl;
1969 0 : SgBitXorOpStorageClass* SgBitXorOpStorageArray = NULL;
1970 0 : if ( 0 < sizeOfActualPool )
1971 : {
1972 0 : SgBitXorOpStorageArray = new SgBitXorOpStorageClass[sizeOfActualPool] ;
1973 0 : unsigned long storageClassIndex = SgBitXorOp::initializeStorageClassArray (SgBitXorOpStorageArray); ;
1974 0 : assert ( storageClassIndex == sizeOfActualPool );
1975 : }
1976 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBlockDataStatement ) ;
1977 0 : std::cout << " SgBlockDataStatement has size " << sizeOfActualPool << std::endl;
1978 0 : SgBlockDataStatementStorageClass* SgBlockDataStatementStorageArray = NULL;
1979 0 : if ( 0 < sizeOfActualPool )
1980 : {
1981 0 : SgBlockDataStatementStorageArray = new SgBlockDataStatementStorageClass[sizeOfActualPool] ;
1982 0 : unsigned long storageClassIndex = SgBlockDataStatement::initializeStorageClassArray (SgBlockDataStatementStorageArray); ;
1983 0 : assert ( storageClassIndex == sizeOfActualPool );
1984 : }
1985 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBoolValExp ) ;
1986 0 : std::cout << " SgBoolValExp has size " << sizeOfActualPool << std::endl;
1987 0 : SgBoolValExpStorageClass* SgBoolValExpStorageArray = NULL;
1988 0 : if ( 0 < sizeOfActualPool )
1989 : {
1990 0 : SgBoolValExpStorageArray = new SgBoolValExpStorageClass[sizeOfActualPool] ;
1991 0 : unsigned long storageClassIndex = SgBoolValExp::initializeStorageClassArray (SgBoolValExpStorageArray); ;
1992 0 : assert ( storageClassIndex == sizeOfActualPool );
1993 : }
1994 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBreakStmt ) ;
1995 0 : std::cout << " SgBreakStmt has size " << sizeOfActualPool << std::endl;
1996 0 : SgBreakStmtStorageClass* SgBreakStmtStorageArray = NULL;
1997 0 : if ( 0 < sizeOfActualPool )
1998 : {
1999 0 : SgBreakStmtStorageArray = new SgBreakStmtStorageClass[sizeOfActualPool] ;
2000 0 : unsigned long storageClassIndex = SgBreakStmt::initializeStorageClassArray (SgBreakStmtStorageArray); ;
2001 0 : assert ( storageClassIndex == sizeOfActualPool );
2002 : }
2003 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgBracedInitializer ) ;
2004 0 : std::cout << " SgBracedInitializer has size " << sizeOfActualPool << std::endl;
2005 0 : SgBracedInitializerStorageClass* SgBracedInitializerStorageArray = NULL;
2006 0 : if ( 0 < sizeOfActualPool )
2007 : {
2008 0 : SgBracedInitializerStorageArray = new SgBracedInitializerStorageClass[sizeOfActualPool] ;
2009 0 : unsigned long storageClassIndex = SgBracedInitializer::initializeStorageClassArray (SgBracedInitializerStorageArray); ;
2010 0 : assert ( storageClassIndex == sizeOfActualPool );
2011 : }
2012 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgC_PreprocessorDirectiveStatement ) ;
2013 0 : std::cout << " SgC_PreprocessorDirectiveStatement has size " << sizeOfActualPool << std::endl;
2014 0 : SgC_PreprocessorDirectiveStatementStorageClass* SgC_PreprocessorDirectiveStatementStorageArray = NULL;
2015 0 : if ( 0 < sizeOfActualPool )
2016 : {
2017 0 : SgC_PreprocessorDirectiveStatementStorageArray = new SgC_PreprocessorDirectiveStatementStorageClass[sizeOfActualPool] ;
2018 0 : unsigned long storageClassIndex = SgC_PreprocessorDirectiveStatement::initializeStorageClassArray (SgC_PreprocessorDirectiveStatementStorageArray); ;
2019 0 : assert ( storageClassIndex == sizeOfActualPool );
2020 : }
2021 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCaseOptionStmt ) ;
2022 0 : std::cout << " SgCaseOptionStmt has size " << sizeOfActualPool << std::endl;
2023 0 : SgCaseOptionStmtStorageClass* SgCaseOptionStmtStorageArray = NULL;
2024 0 : if ( 0 < sizeOfActualPool )
2025 : {
2026 0 : SgCaseOptionStmtStorageArray = new SgCaseOptionStmtStorageClass[sizeOfActualPool] ;
2027 0 : unsigned long storageClassIndex = SgCaseOptionStmt::initializeStorageClassArray (SgCaseOptionStmtStorageArray); ;
2028 0 : assert ( storageClassIndex == sizeOfActualPool );
2029 : }
2030 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCastExp ) ;
2031 0 : std::cout << " SgCastExp has size " << sizeOfActualPool << std::endl;
2032 0 : SgCastExpStorageClass* SgCastExpStorageArray = NULL;
2033 0 : if ( 0 < sizeOfActualPool )
2034 : {
2035 0 : SgCastExpStorageArray = new SgCastExpStorageClass[sizeOfActualPool] ;
2036 0 : unsigned long storageClassIndex = SgCastExp::initializeStorageClassArray (SgCastExpStorageArray); ;
2037 0 : assert ( storageClassIndex == sizeOfActualPool );
2038 : }
2039 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCatchOptionStmt ) ;
2040 0 : std::cout << " SgCatchOptionStmt has size " << sizeOfActualPool << std::endl;
2041 0 : SgCatchOptionStmtStorageClass* SgCatchOptionStmtStorageArray = NULL;
2042 0 : if ( 0 < sizeOfActualPool )
2043 : {
2044 0 : SgCatchOptionStmtStorageArray = new SgCatchOptionStmtStorageClass[sizeOfActualPool] ;
2045 0 : unsigned long storageClassIndex = SgCatchOptionStmt::initializeStorageClassArray (SgCatchOptionStmtStorageArray); ;
2046 0 : assert ( storageClassIndex == sizeOfActualPool );
2047 : }
2048 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCatchStatementSeq ) ;
2049 0 : std::cout << " SgCatchStatementSeq has size " << sizeOfActualPool << std::endl;
2050 0 : SgCatchStatementSeqStorageClass* SgCatchStatementSeqStorageArray = NULL;
2051 0 : if ( 0 < sizeOfActualPool )
2052 : {
2053 0 : SgCatchStatementSeqStorageArray = new SgCatchStatementSeqStorageClass[sizeOfActualPool] ;
2054 0 : unsigned long storageClassIndex = SgCatchStatementSeq::initializeStorageClassArray (SgCatchStatementSeqStorageArray); ;
2055 0 : assert ( storageClassIndex == sizeOfActualPool );
2056 : }
2057 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCharVal ) ;
2058 0 : std::cout << " SgCharVal has size " << sizeOfActualPool << std::endl;
2059 0 : SgCharValStorageClass* SgCharValStorageArray = NULL;
2060 0 : if ( 0 < sizeOfActualPool )
2061 : {
2062 0 : SgCharValStorageArray = new SgCharValStorageClass[sizeOfActualPool] ;
2063 0 : unsigned long storageClassIndex = SgCharVal::initializeStorageClassArray (SgCharValStorageArray); ;
2064 0 : assert ( storageClassIndex == sizeOfActualPool );
2065 : }
2066 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgChar16Val ) ;
2067 0 : std::cout << " SgChar16Val has size " << sizeOfActualPool << std::endl;
2068 0 : SgChar16ValStorageClass* SgChar16ValStorageArray = NULL;
2069 0 : if ( 0 < sizeOfActualPool )
2070 : {
2071 0 : SgChar16ValStorageArray = new SgChar16ValStorageClass[sizeOfActualPool] ;
2072 0 : unsigned long storageClassIndex = SgChar16Val::initializeStorageClassArray (SgChar16ValStorageArray); ;
2073 0 : assert ( storageClassIndex == sizeOfActualPool );
2074 : }
2075 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgChar32Val ) ;
2076 0 : std::cout << " SgChar32Val has size " << sizeOfActualPool << std::endl;
2077 0 : SgChar32ValStorageClass* SgChar32ValStorageArray = NULL;
2078 0 : if ( 0 < sizeOfActualPool )
2079 : {
2080 0 : SgChar32ValStorageArray = new SgChar32ValStorageClass[sizeOfActualPool] ;
2081 0 : unsigned long storageClassIndex = SgChar32Val::initializeStorageClassArray (SgChar32ValStorageArray); ;
2082 0 : assert ( storageClassIndex == sizeOfActualPool );
2083 : }
2084 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgChooseExpression ) ;
2085 0 : std::cout << " SgChooseExpression has size " << sizeOfActualPool << std::endl;
2086 0 : SgChooseExpressionStorageClass* SgChooseExpressionStorageArray = NULL;
2087 0 : if ( 0 < sizeOfActualPool )
2088 : {
2089 0 : SgChooseExpressionStorageArray = new SgChooseExpressionStorageClass[sizeOfActualPool] ;
2090 0 : unsigned long storageClassIndex = SgChooseExpression::initializeStorageClassArray (SgChooseExpressionStorageArray); ;
2091 0 : assert ( storageClassIndex == sizeOfActualPool );
2092 : }
2093 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassDecl_attr ) ;
2094 0 : std::cout << " SgClassDecl_attr has size " << sizeOfActualPool << std::endl;
2095 0 : SgClassDecl_attrStorageClass* SgClassDecl_attrStorageArray = NULL;
2096 0 : if ( 0 < sizeOfActualPool )
2097 : {
2098 0 : SgClassDecl_attrStorageArray = new SgClassDecl_attrStorageClass[sizeOfActualPool] ;
2099 0 : unsigned long storageClassIndex = SgClassDecl_attr::initializeStorageClassArray (SgClassDecl_attrStorageArray); ;
2100 0 : assert ( storageClassIndex == sizeOfActualPool );
2101 : }
2102 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassDeclaration ) ;
2103 0 : std::cout << " SgClassDeclaration has size " << sizeOfActualPool << std::endl;
2104 0 : SgClassDeclarationStorageClass* SgClassDeclarationStorageArray = NULL;
2105 0 : if ( 0 < sizeOfActualPool )
2106 : {
2107 0 : SgClassDeclarationStorageArray = new SgClassDeclarationStorageClass[sizeOfActualPool] ;
2108 0 : unsigned long storageClassIndex = SgClassDeclaration::initializeStorageClassArray (SgClassDeclarationStorageArray); ;
2109 0 : assert ( storageClassIndex == sizeOfActualPool );
2110 : }
2111 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassDefinition ) ;
2112 0 : std::cout << " SgClassDefinition has size " << sizeOfActualPool << std::endl;
2113 0 : SgClassDefinitionStorageClass* SgClassDefinitionStorageArray = NULL;
2114 0 : if ( 0 < sizeOfActualPool )
2115 : {
2116 0 : SgClassDefinitionStorageArray = new SgClassDefinitionStorageClass[sizeOfActualPool] ;
2117 0 : unsigned long storageClassIndex = SgClassDefinition::initializeStorageClassArray (SgClassDefinitionStorageArray); ;
2118 0 : assert ( storageClassIndex == sizeOfActualPool );
2119 : }
2120 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassNameRefExp ) ;
2121 0 : std::cout << " SgClassNameRefExp has size " << sizeOfActualPool << std::endl;
2122 0 : SgClassNameRefExpStorageClass* SgClassNameRefExpStorageArray = NULL;
2123 0 : if ( 0 < sizeOfActualPool )
2124 : {
2125 0 : SgClassNameRefExpStorageArray = new SgClassNameRefExpStorageClass[sizeOfActualPool] ;
2126 0 : unsigned long storageClassIndex = SgClassNameRefExp::initializeStorageClassArray (SgClassNameRefExpStorageArray); ;
2127 0 : assert ( storageClassIndex == sizeOfActualPool );
2128 : }
2129 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassSymbol ) ;
2130 0 : std::cout << " SgClassSymbol has size " << sizeOfActualPool << std::endl;
2131 0 : SgClassSymbolStorageClass* SgClassSymbolStorageArray = NULL;
2132 0 : if ( 0 < sizeOfActualPool )
2133 : {
2134 0 : SgClassSymbolStorageArray = new SgClassSymbolStorageClass[sizeOfActualPool] ;
2135 0 : unsigned long storageClassIndex = SgClassSymbol::initializeStorageClassArray (SgClassSymbolStorageArray); ;
2136 0 : assert ( storageClassIndex == sizeOfActualPool );
2137 : }
2138 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassType ) ;
2139 0 : std::cout << " SgClassType has size " << sizeOfActualPool << std::endl;
2140 0 : SgClassTypeStorageClass* SgClassTypeStorageArray = NULL;
2141 0 : if ( 0 < sizeOfActualPool )
2142 : {
2143 0 : SgClassTypeStorageArray = new SgClassTypeStorageClass[sizeOfActualPool] ;
2144 0 : unsigned long storageClassIndex = SgClassType::initializeStorageClassArray (SgClassTypeStorageArray); ;
2145 0 : assert ( storageClassIndex == sizeOfActualPool );
2146 : }
2147 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClinkageDeclarationStatement ) ;
2148 0 : std::cout << " SgClinkageDeclarationStatement has size " << sizeOfActualPool << std::endl;
2149 0 : SgClinkageDeclarationStatementStorageClass* SgClinkageDeclarationStatementStorageArray = NULL;
2150 0 : if ( 0 < sizeOfActualPool )
2151 : {
2152 0 : SgClinkageDeclarationStatementStorageArray = new SgClinkageDeclarationStatementStorageClass[sizeOfActualPool] ;
2153 0 : unsigned long storageClassIndex = SgClinkageDeclarationStatement::initializeStorageClassArray (SgClinkageDeclarationStatementStorageArray); ;
2154 0 : assert ( storageClassIndex == sizeOfActualPool );
2155 : }
2156 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClinkageEndStatement ) ;
2157 0 : std::cout << " SgClinkageEndStatement has size " << sizeOfActualPool << std::endl;
2158 0 : SgClinkageEndStatementStorageClass* SgClinkageEndStatementStorageArray = NULL;
2159 0 : if ( 0 < sizeOfActualPool )
2160 : {
2161 0 : SgClinkageEndStatementStorageArray = new SgClinkageEndStatementStorageClass[sizeOfActualPool] ;
2162 0 : unsigned long storageClassIndex = SgClinkageEndStatement::initializeStorageClassArray (SgClinkageEndStatementStorageArray); ;
2163 0 : assert ( storageClassIndex == sizeOfActualPool );
2164 : }
2165 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClinkageStartStatement ) ;
2166 0 : std::cout << " SgClinkageStartStatement has size " << sizeOfActualPool << std::endl;
2167 0 : SgClinkageStartStatementStorageClass* SgClinkageStartStatementStorageArray = NULL;
2168 0 : if ( 0 < sizeOfActualPool )
2169 : {
2170 0 : SgClinkageStartStatementStorageArray = new SgClinkageStartStatementStorageClass[sizeOfActualPool] ;
2171 0 : unsigned long storageClassIndex = SgClinkageStartStatement::initializeStorageClassArray (SgClinkageStartStatementStorageArray); ;
2172 0 : assert ( storageClassIndex == sizeOfActualPool );
2173 : }
2174 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCloseStatement ) ;
2175 0 : std::cout << " SgCloseStatement has size " << sizeOfActualPool << std::endl;
2176 0 : SgCloseStatementStorageClass* SgCloseStatementStorageArray = NULL;
2177 0 : if ( 0 < sizeOfActualPool )
2178 : {
2179 0 : SgCloseStatementStorageArray = new SgCloseStatementStorageClass[sizeOfActualPool] ;
2180 0 : unsigned long storageClassIndex = SgCloseStatement::initializeStorageClassArray (SgCloseStatementStorageArray); ;
2181 0 : assert ( storageClassIndex == sizeOfActualPool );
2182 : }
2183 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgColonShapeExp ) ;
2184 0 : std::cout << " SgColonShapeExp has size " << sizeOfActualPool << std::endl;
2185 0 : SgColonShapeExpStorageClass* SgColonShapeExpStorageArray = NULL;
2186 0 : if ( 0 < sizeOfActualPool )
2187 : {
2188 0 : SgColonShapeExpStorageArray = new SgColonShapeExpStorageClass[sizeOfActualPool] ;
2189 0 : unsigned long storageClassIndex = SgColonShapeExp::initializeStorageClassArray (SgColonShapeExpStorageArray); ;
2190 0 : assert ( storageClassIndex == sizeOfActualPool );
2191 : }
2192 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCommaOpExp ) ;
2193 0 : std::cout << " SgCommaOpExp has size " << sizeOfActualPool << std::endl;
2194 0 : SgCommaOpExpStorageClass* SgCommaOpExpStorageArray = NULL;
2195 0 : if ( 0 < sizeOfActualPool )
2196 : {
2197 0 : SgCommaOpExpStorageArray = new SgCommaOpExpStorageClass[sizeOfActualPool] ;
2198 0 : unsigned long storageClassIndex = SgCommaOpExp::initializeStorageClassArray (SgCommaOpExpStorageArray); ;
2199 0 : assert ( storageClassIndex == sizeOfActualPool );
2200 : }
2201 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCommonBlock ) ;
2202 0 : std::cout << " SgCommonBlock has size " << sizeOfActualPool << std::endl;
2203 0 : SgCommonBlockStorageClass* SgCommonBlockStorageArray = NULL;
2204 0 : if ( 0 < sizeOfActualPool )
2205 : {
2206 0 : SgCommonBlockStorageArray = new SgCommonBlockStorageClass[sizeOfActualPool] ;
2207 0 : unsigned long storageClassIndex = SgCommonBlock::initializeStorageClassArray (SgCommonBlockStorageArray); ;
2208 0 : assert ( storageClassIndex == sizeOfActualPool );
2209 : }
2210 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCommonBlockObject ) ;
2211 0 : std::cout << " SgCommonBlockObject has size " << sizeOfActualPool << std::endl;
2212 0 : SgCommonBlockObjectStorageClass* SgCommonBlockObjectStorageArray = NULL;
2213 0 : if ( 0 < sizeOfActualPool )
2214 : {
2215 0 : SgCommonBlockObjectStorageArray = new SgCommonBlockObjectStorageClass[sizeOfActualPool] ;
2216 0 : unsigned long storageClassIndex = SgCommonBlockObject::initializeStorageClassArray (SgCommonBlockObjectStorageArray); ;
2217 0 : assert ( storageClassIndex == sizeOfActualPool );
2218 : }
2219 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCommonSymbol ) ;
2220 0 : std::cout << " SgCommonSymbol has size " << sizeOfActualPool << std::endl;
2221 0 : SgCommonSymbolStorageClass* SgCommonSymbolStorageArray = NULL;
2222 0 : if ( 0 < sizeOfActualPool )
2223 : {
2224 0 : SgCommonSymbolStorageArray = new SgCommonSymbolStorageClass[sizeOfActualPool] ;
2225 0 : unsigned long storageClassIndex = SgCommonSymbol::initializeStorageClassArray (SgCommonSymbolStorageArray); ;
2226 0 : assert ( storageClassIndex == sizeOfActualPool );
2227 : }
2228 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgComplexVal ) ;
2229 0 : std::cout << " SgComplexVal has size " << sizeOfActualPool << std::endl;
2230 0 : SgComplexValStorageClass* SgComplexValStorageArray = NULL;
2231 0 : if ( 0 < sizeOfActualPool )
2232 : {
2233 0 : SgComplexValStorageArray = new SgComplexValStorageClass[sizeOfActualPool] ;
2234 0 : unsigned long storageClassIndex = SgComplexVal::initializeStorageClassArray (SgComplexValStorageArray); ;
2235 0 : assert ( storageClassIndex == sizeOfActualPool );
2236 : }
2237 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgComprehension ) ;
2238 0 : std::cout << " SgComprehension has size " << sizeOfActualPool << std::endl;
2239 0 : SgComprehensionStorageClass* SgComprehensionStorageArray = NULL;
2240 0 : if ( 0 < sizeOfActualPool )
2241 : {
2242 0 : SgComprehensionStorageArray = new SgComprehensionStorageClass[sizeOfActualPool] ;
2243 0 : unsigned long storageClassIndex = SgComprehension::initializeStorageClassArray (SgComprehensionStorageArray); ;
2244 0 : assert ( storageClassIndex == sizeOfActualPool );
2245 : }
2246 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCompoundAssignOp ) ;
2247 0 : std::cout << " SgCompoundAssignOp has size " << sizeOfActualPool << std::endl;
2248 0 : SgCompoundAssignOpStorageClass* SgCompoundAssignOpStorageArray = NULL;
2249 0 : if ( 0 < sizeOfActualPool )
2250 : {
2251 0 : SgCompoundAssignOpStorageArray = new SgCompoundAssignOpStorageClass[sizeOfActualPool] ;
2252 0 : unsigned long storageClassIndex = SgCompoundAssignOp::initializeStorageClassArray (SgCompoundAssignOpStorageArray); ;
2253 0 : assert ( storageClassIndex == sizeOfActualPool );
2254 : }
2255 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCompoundInitializer ) ;
2256 0 : std::cout << " SgCompoundInitializer has size " << sizeOfActualPool << std::endl;
2257 0 : SgCompoundInitializerStorageClass* SgCompoundInitializerStorageArray = NULL;
2258 0 : if ( 0 < sizeOfActualPool )
2259 : {
2260 0 : SgCompoundInitializerStorageArray = new SgCompoundInitializerStorageClass[sizeOfActualPool] ;
2261 0 : unsigned long storageClassIndex = SgCompoundInitializer::initializeStorageClassArray (SgCompoundInitializerStorageArray); ;
2262 0 : assert ( storageClassIndex == sizeOfActualPool );
2263 : }
2264 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCompoundLiteralExp ) ;
2265 0 : std::cout << " SgCompoundLiteralExp has size " << sizeOfActualPool << std::endl;
2266 0 : SgCompoundLiteralExpStorageClass* SgCompoundLiteralExpStorageArray = NULL;
2267 0 : if ( 0 < sizeOfActualPool )
2268 : {
2269 0 : SgCompoundLiteralExpStorageArray = new SgCompoundLiteralExpStorageClass[sizeOfActualPool] ;
2270 0 : unsigned long storageClassIndex = SgCompoundLiteralExp::initializeStorageClassArray (SgCompoundLiteralExpStorageArray); ;
2271 0 : assert ( storageClassIndex == sizeOfActualPool );
2272 : }
2273 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgComputedGotoStatement ) ;
2274 0 : std::cout << " SgComputedGotoStatement has size " << sizeOfActualPool << std::endl;
2275 0 : SgComputedGotoStatementStorageClass* SgComputedGotoStatementStorageArray = NULL;
2276 0 : if ( 0 < sizeOfActualPool )
2277 : {
2278 0 : SgComputedGotoStatementStorageArray = new SgComputedGotoStatementStorageClass[sizeOfActualPool] ;
2279 0 : unsigned long storageClassIndex = SgComputedGotoStatement::initializeStorageClassArray (SgComputedGotoStatementStorageArray); ;
2280 0 : assert ( storageClassIndex == sizeOfActualPool );
2281 : }
2282 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgConcatenationOp ) ;
2283 0 : std::cout << " SgConcatenationOp has size " << sizeOfActualPool << std::endl;
2284 0 : SgConcatenationOpStorageClass* SgConcatenationOpStorageArray = NULL;
2285 0 : if ( 0 < sizeOfActualPool )
2286 : {
2287 0 : SgConcatenationOpStorageArray = new SgConcatenationOpStorageClass[sizeOfActualPool] ;
2288 0 : unsigned long storageClassIndex = SgConcatenationOp::initializeStorageClassArray (SgConcatenationOpStorageArray); ;
2289 0 : assert ( storageClassIndex == sizeOfActualPool );
2290 : }
2291 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgConditionalExp ) ;
2292 0 : std::cout << " SgConditionalExp has size " << sizeOfActualPool << std::endl;
2293 0 : SgConditionalExpStorageClass* SgConditionalExpStorageArray = NULL;
2294 0 : if ( 0 < sizeOfActualPool )
2295 : {
2296 0 : SgConditionalExpStorageArray = new SgConditionalExpStorageClass[sizeOfActualPool] ;
2297 0 : unsigned long storageClassIndex = SgConditionalExp::initializeStorageClassArray (SgConditionalExpStorageArray); ;
2298 0 : assert ( storageClassIndex == sizeOfActualPool );
2299 : }
2300 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgConjugateOp ) ;
2301 0 : std::cout << " SgConjugateOp has size " << sizeOfActualPool << std::endl;
2302 0 : SgConjugateOpStorageClass* SgConjugateOpStorageArray = NULL;
2303 0 : if ( 0 < sizeOfActualPool )
2304 : {
2305 0 : SgConjugateOpStorageArray = new SgConjugateOpStorageClass[sizeOfActualPool] ;
2306 0 : unsigned long storageClassIndex = SgConjugateOp::initializeStorageClassArray (SgConjugateOpStorageArray); ;
2307 0 : assert ( storageClassIndex == sizeOfActualPool );
2308 : }
2309 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgConstVolatileModifier ) ;
2310 0 : std::cout << " SgConstVolatileModifier has size " << sizeOfActualPool << std::endl;
2311 0 : SgConstVolatileModifierStorageClass* SgConstVolatileModifierStorageArray = NULL;
2312 0 : if ( 0 < sizeOfActualPool )
2313 : {
2314 0 : SgConstVolatileModifierStorageArray = new SgConstVolatileModifierStorageClass[sizeOfActualPool] ;
2315 0 : unsigned long storageClassIndex = SgConstVolatileModifier::initializeStorageClassArray (SgConstVolatileModifierStorageArray); ;
2316 0 : assert ( storageClassIndex == sizeOfActualPool );
2317 : }
2318 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgConstructorInitializer ) ;
2319 0 : std::cout << " SgConstructorInitializer has size " << sizeOfActualPool << std::endl;
2320 0 : SgConstructorInitializerStorageClass* SgConstructorInitializerStorageArray = NULL;
2321 0 : if ( 0 < sizeOfActualPool )
2322 : {
2323 0 : SgConstructorInitializerStorageArray = new SgConstructorInitializerStorageClass[sizeOfActualPool] ;
2324 0 : unsigned long storageClassIndex = SgConstructorInitializer::initializeStorageClassArray (SgConstructorInitializerStorageArray); ;
2325 0 : assert ( storageClassIndex == sizeOfActualPool );
2326 : }
2327 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgContainsStatement ) ;
2328 0 : std::cout << " SgContainsStatement has size " << sizeOfActualPool << std::endl;
2329 0 : SgContainsStatementStorageClass* SgContainsStatementStorageArray = NULL;
2330 0 : if ( 0 < sizeOfActualPool )
2331 : {
2332 0 : SgContainsStatementStorageArray = new SgContainsStatementStorageClass[sizeOfActualPool] ;
2333 0 : unsigned long storageClassIndex = SgContainsStatement::initializeStorageClassArray (SgContainsStatementStorageArray); ;
2334 0 : assert ( storageClassIndex == sizeOfActualPool );
2335 : }
2336 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgContinueStmt ) ;
2337 0 : std::cout << " SgContinueStmt has size " << sizeOfActualPool << std::endl;
2338 0 : SgContinueStmtStorageClass* SgContinueStmtStorageArray = NULL;
2339 0 : if ( 0 < sizeOfActualPool )
2340 : {
2341 0 : SgContinueStmtStorageArray = new SgContinueStmtStorageClass[sizeOfActualPool] ;
2342 0 : unsigned long storageClassIndex = SgContinueStmt::initializeStorageClassArray (SgContinueStmtStorageArray); ;
2343 0 : assert ( storageClassIndex == sizeOfActualPool );
2344 : }
2345 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCtorInitializerList ) ;
2346 0 : std::cout << " SgCtorInitializerList has size " << sizeOfActualPool << std::endl;
2347 0 : SgCtorInitializerListStorageClass* SgCtorInitializerListStorageArray = NULL;
2348 0 : if ( 0 < sizeOfActualPool )
2349 : {
2350 0 : SgCtorInitializerListStorageArray = new SgCtorInitializerListStorageClass[sizeOfActualPool] ;
2351 0 : unsigned long storageClassIndex = SgCtorInitializerList::initializeStorageClassArray (SgCtorInitializerListStorageArray); ;
2352 0 : assert ( storageClassIndex == sizeOfActualPool );
2353 : }
2354 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDataStatementGroup ) ;
2355 0 : std::cout << " SgDataStatementGroup has size " << sizeOfActualPool << std::endl;
2356 0 : SgDataStatementGroupStorageClass* SgDataStatementGroupStorageArray = NULL;
2357 0 : if ( 0 < sizeOfActualPool )
2358 : {
2359 0 : SgDataStatementGroupStorageArray = new SgDataStatementGroupStorageClass[sizeOfActualPool] ;
2360 0 : unsigned long storageClassIndex = SgDataStatementGroup::initializeStorageClassArray (SgDataStatementGroupStorageArray); ;
2361 0 : assert ( storageClassIndex == sizeOfActualPool );
2362 : }
2363 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDataStatementObject ) ;
2364 0 : std::cout << " SgDataStatementObject has size " << sizeOfActualPool << std::endl;
2365 0 : SgDataStatementObjectStorageClass* SgDataStatementObjectStorageArray = NULL;
2366 0 : if ( 0 < sizeOfActualPool )
2367 : {
2368 0 : SgDataStatementObjectStorageArray = new SgDataStatementObjectStorageClass[sizeOfActualPool] ;
2369 0 : unsigned long storageClassIndex = SgDataStatementObject::initializeStorageClassArray (SgDataStatementObjectStorageArray); ;
2370 0 : assert ( storageClassIndex == sizeOfActualPool );
2371 : }
2372 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDataStatementValue ) ;
2373 0 : std::cout << " SgDataStatementValue has size " << sizeOfActualPool << std::endl;
2374 0 : SgDataStatementValueStorageClass* SgDataStatementValueStorageArray = NULL;
2375 0 : if ( 0 < sizeOfActualPool )
2376 : {
2377 0 : SgDataStatementValueStorageArray = new SgDataStatementValueStorageClass[sizeOfActualPool] ;
2378 0 : unsigned long storageClassIndex = SgDataStatementValue::initializeStorageClassArray (SgDataStatementValueStorageArray); ;
2379 0 : assert ( storageClassIndex == sizeOfActualPool );
2380 : }
2381 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeadIfDirectiveStatement ) ;
2382 0 : std::cout << " SgDeadIfDirectiveStatement has size " << sizeOfActualPool << std::endl;
2383 0 : SgDeadIfDirectiveStatementStorageClass* SgDeadIfDirectiveStatementStorageArray = NULL;
2384 0 : if ( 0 < sizeOfActualPool )
2385 : {
2386 0 : SgDeadIfDirectiveStatementStorageArray = new SgDeadIfDirectiveStatementStorageClass[sizeOfActualPool] ;
2387 0 : unsigned long storageClassIndex = SgDeadIfDirectiveStatement::initializeStorageClassArray (SgDeadIfDirectiveStatementStorageArray); ;
2388 0 : assert ( storageClassIndex == sizeOfActualPool );
2389 : }
2390 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeallocateStatement ) ;
2391 0 : std::cout << " SgDeallocateStatement has size " << sizeOfActualPool << std::endl;
2392 0 : SgDeallocateStatementStorageClass* SgDeallocateStatementStorageArray = NULL;
2393 0 : if ( 0 < sizeOfActualPool )
2394 : {
2395 0 : SgDeallocateStatementStorageArray = new SgDeallocateStatementStorageClass[sizeOfActualPool] ;
2396 0 : unsigned long storageClassIndex = SgDeallocateStatement::initializeStorageClassArray (SgDeallocateStatementStorageArray); ;
2397 0 : assert ( storageClassIndex == sizeOfActualPool );
2398 : }
2399 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeclarationModifier ) ;
2400 0 : std::cout << " SgDeclarationModifier has size " << sizeOfActualPool << std::endl;
2401 0 : SgDeclarationModifierStorageClass* SgDeclarationModifierStorageArray = NULL;
2402 0 : if ( 0 < sizeOfActualPool )
2403 : {
2404 0 : SgDeclarationModifierStorageArray = new SgDeclarationModifierStorageClass[sizeOfActualPool] ;
2405 0 : unsigned long storageClassIndex = SgDeclarationModifier::initializeStorageClassArray (SgDeclarationModifierStorageArray); ;
2406 0 : assert ( storageClassIndex == sizeOfActualPool );
2407 : }
2408 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeclarationScope ) ;
2409 0 : std::cout << " SgDeclarationScope has size " << sizeOfActualPool << std::endl;
2410 0 : SgDeclarationScopeStorageClass* SgDeclarationScopeStorageArray = NULL;
2411 0 : if ( 0 < sizeOfActualPool )
2412 : {
2413 0 : SgDeclarationScopeStorageArray = new SgDeclarationScopeStorageClass[sizeOfActualPool] ;
2414 0 : unsigned long storageClassIndex = SgDeclarationScope::initializeStorageClassArray (SgDeclarationScopeStorageArray); ;
2415 0 : assert ( storageClassIndex == sizeOfActualPool );
2416 : }
2417 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeclarationStatement ) ;
2418 0 : std::cout << " SgDeclarationStatement has size " << sizeOfActualPool << std::endl;
2419 0 : SgDeclarationStatementStorageClass* SgDeclarationStatementStorageArray = NULL;
2420 0 : if ( 0 < sizeOfActualPool )
2421 : {
2422 0 : SgDeclarationStatementStorageArray = new SgDeclarationStatementStorageClass[sizeOfActualPool] ;
2423 0 : unsigned long storageClassIndex = SgDeclarationStatement::initializeStorageClassArray (SgDeclarationStatementStorageArray); ;
2424 0 : assert ( storageClassIndex == sizeOfActualPool );
2425 : }
2426 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeclType ) ;
2427 0 : std::cout << " SgDeclType has size " << sizeOfActualPool << std::endl;
2428 0 : SgDeclTypeStorageClass* SgDeclTypeStorageArray = NULL;
2429 0 : if ( 0 < sizeOfActualPool )
2430 : {
2431 0 : SgDeclTypeStorageArray = new SgDeclTypeStorageClass[sizeOfActualPool] ;
2432 0 : unsigned long storageClassIndex = SgDeclType::initializeStorageClassArray (SgDeclTypeStorageArray); ;
2433 0 : assert ( storageClassIndex == sizeOfActualPool );
2434 : }
2435 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDefaultOptionStmt ) ;
2436 0 : std::cout << " SgDefaultOptionStmt has size " << sizeOfActualPool << std::endl;
2437 0 : SgDefaultOptionStmtStorageClass* SgDefaultOptionStmtStorageArray = NULL;
2438 0 : if ( 0 < sizeOfActualPool )
2439 : {
2440 0 : SgDefaultOptionStmtStorageArray = new SgDefaultOptionStmtStorageClass[sizeOfActualPool] ;
2441 0 : unsigned long storageClassIndex = SgDefaultOptionStmt::initializeStorageClassArray (SgDefaultOptionStmtStorageArray); ;
2442 0 : assert ( storageClassIndex == sizeOfActualPool );
2443 : }
2444 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDefaultSymbol ) ;
2445 0 : std::cout << " SgDefaultSymbol has size " << sizeOfActualPool << std::endl;
2446 0 : SgDefaultSymbolStorageClass* SgDefaultSymbolStorageArray = NULL;
2447 0 : if ( 0 < sizeOfActualPool )
2448 : {
2449 0 : SgDefaultSymbolStorageArray = new SgDefaultSymbolStorageClass[sizeOfActualPool] ;
2450 0 : unsigned long storageClassIndex = SgDefaultSymbol::initializeStorageClassArray (SgDefaultSymbolStorageArray); ;
2451 0 : assert ( storageClassIndex == sizeOfActualPool );
2452 : }
2453 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDefineDirectiveStatement ) ;
2454 0 : std::cout << " SgDefineDirectiveStatement has size " << sizeOfActualPool << std::endl;
2455 0 : SgDefineDirectiveStatementStorageClass* SgDefineDirectiveStatementStorageArray = NULL;
2456 0 : if ( 0 < sizeOfActualPool )
2457 : {
2458 0 : SgDefineDirectiveStatementStorageArray = new SgDefineDirectiveStatementStorageClass[sizeOfActualPool] ;
2459 0 : unsigned long storageClassIndex = SgDefineDirectiveStatement::initializeStorageClassArray (SgDefineDirectiveStatementStorageArray); ;
2460 0 : assert ( storageClassIndex == sizeOfActualPool );
2461 : }
2462 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDeleteExp ) ;
2463 0 : std::cout << " SgDeleteExp has size " << sizeOfActualPool << std::endl;
2464 0 : SgDeleteExpStorageClass* SgDeleteExpStorageArray = NULL;
2465 0 : if ( 0 < sizeOfActualPool )
2466 : {
2467 0 : SgDeleteExpStorageArray = new SgDeleteExpStorageClass[sizeOfActualPool] ;
2468 0 : unsigned long storageClassIndex = SgDeleteExp::initializeStorageClassArray (SgDeleteExpStorageArray); ;
2469 0 : assert ( storageClassIndex == sizeOfActualPool );
2470 : }
2471 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDerivedTypeStatement ) ;
2472 0 : std::cout << " SgDerivedTypeStatement has size " << sizeOfActualPool << std::endl;
2473 0 : SgDerivedTypeStatementStorageClass* SgDerivedTypeStatementStorageArray = NULL;
2474 0 : if ( 0 < sizeOfActualPool )
2475 : {
2476 0 : SgDerivedTypeStatementStorageArray = new SgDerivedTypeStatementStorageClass[sizeOfActualPool] ;
2477 0 : unsigned long storageClassIndex = SgDerivedTypeStatement::initializeStorageClassArray (SgDerivedTypeStatementStorageArray); ;
2478 0 : assert ( storageClassIndex == sizeOfActualPool );
2479 : }
2480 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDesignatedInitializer ) ;
2481 0 : std::cout << " SgDesignatedInitializer has size " << sizeOfActualPool << std::endl;
2482 0 : SgDesignatedInitializerStorageClass* SgDesignatedInitializerStorageArray = NULL;
2483 0 : if ( 0 < sizeOfActualPool )
2484 : {
2485 0 : SgDesignatedInitializerStorageArray = new SgDesignatedInitializerStorageClass[sizeOfActualPool] ;
2486 0 : unsigned long storageClassIndex = SgDesignatedInitializer::initializeStorageClassArray (SgDesignatedInitializerStorageArray); ;
2487 0 : assert ( storageClassIndex == sizeOfActualPool );
2488 : }
2489 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDictionaryComprehension ) ;
2490 0 : std::cout << " SgDictionaryComprehension has size " << sizeOfActualPool << std::endl;
2491 0 : SgDictionaryComprehensionStorageClass* SgDictionaryComprehensionStorageArray = NULL;
2492 0 : if ( 0 < sizeOfActualPool )
2493 : {
2494 0 : SgDictionaryComprehensionStorageArray = new SgDictionaryComprehensionStorageClass[sizeOfActualPool] ;
2495 0 : unsigned long storageClassIndex = SgDictionaryComprehension::initializeStorageClassArray (SgDictionaryComprehensionStorageArray); ;
2496 0 : assert ( storageClassIndex == sizeOfActualPool );
2497 : }
2498 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDictionaryExp ) ;
2499 0 : std::cout << " SgDictionaryExp has size " << sizeOfActualPool << std::endl;
2500 0 : SgDictionaryExpStorageClass* SgDictionaryExpStorageArray = NULL;
2501 0 : if ( 0 < sizeOfActualPool )
2502 : {
2503 0 : SgDictionaryExpStorageArray = new SgDictionaryExpStorageClass[sizeOfActualPool] ;
2504 0 : unsigned long storageClassIndex = SgDictionaryExp::initializeStorageClassArray (SgDictionaryExpStorageArray); ;
2505 0 : assert ( storageClassIndex == sizeOfActualPool );
2506 : }
2507 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDimensionObject ) ;
2508 0 : std::cout << " SgDimensionObject has size " << sizeOfActualPool << std::endl;
2509 0 : SgDimensionObjectStorageClass* SgDimensionObjectStorageArray = NULL;
2510 0 : if ( 0 < sizeOfActualPool )
2511 : {
2512 0 : SgDimensionObjectStorageArray = new SgDimensionObjectStorageClass[sizeOfActualPool] ;
2513 0 : unsigned long storageClassIndex = SgDimensionObject::initializeStorageClassArray (SgDimensionObjectStorageArray); ;
2514 0 : assert ( storageClassIndex == sizeOfActualPool );
2515 : }
2516 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDirectedGraphEdge ) ;
2517 0 : std::cout << " SgDirectedGraphEdge has size " << sizeOfActualPool << std::endl;
2518 0 : SgDirectedGraphEdgeStorageClass* SgDirectedGraphEdgeStorageArray = NULL;
2519 0 : if ( 0 < sizeOfActualPool )
2520 : {
2521 0 : SgDirectedGraphEdgeStorageArray = new SgDirectedGraphEdgeStorageClass[sizeOfActualPool] ;
2522 0 : unsigned long storageClassIndex = SgDirectedGraphEdge::initializeStorageClassArray (SgDirectedGraphEdgeStorageArray); ;
2523 0 : assert ( storageClassIndex == sizeOfActualPool );
2524 : }
2525 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDirectory ) ;
2526 0 : std::cout << " SgDirectory has size " << sizeOfActualPool << std::endl;
2527 0 : SgDirectoryStorageClass* SgDirectoryStorageArray = NULL;
2528 0 : if ( 0 < sizeOfActualPool )
2529 : {
2530 0 : SgDirectoryStorageArray = new SgDirectoryStorageClass[sizeOfActualPool] ;
2531 0 : unsigned long storageClassIndex = SgDirectory::initializeStorageClassArray (SgDirectoryStorageArray); ;
2532 0 : assert ( storageClassIndex == sizeOfActualPool );
2533 : }
2534 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDirectoryList ) ;
2535 0 : std::cout << " SgDirectoryList has size " << sizeOfActualPool << std::endl;
2536 0 : SgDirectoryListStorageClass* SgDirectoryListStorageArray = NULL;
2537 0 : if ( 0 < sizeOfActualPool )
2538 : {
2539 0 : SgDirectoryListStorageArray = new SgDirectoryListStorageClass[sizeOfActualPool] ;
2540 0 : unsigned long storageClassIndex = SgDirectoryList::initializeStorageClassArray (SgDirectoryListStorageArray); ;
2541 0 : assert ( storageClassIndex == sizeOfActualPool );
2542 : }
2543 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDivAssignOp ) ;
2544 0 : std::cout << " SgDivAssignOp has size " << sizeOfActualPool << std::endl;
2545 0 : SgDivAssignOpStorageClass* SgDivAssignOpStorageArray = NULL;
2546 0 : if ( 0 < sizeOfActualPool )
2547 : {
2548 0 : SgDivAssignOpStorageArray = new SgDivAssignOpStorageClass[sizeOfActualPool] ;
2549 0 : unsigned long storageClassIndex = SgDivAssignOp::initializeStorageClassArray (SgDivAssignOpStorageArray); ;
2550 0 : assert ( storageClassIndex == sizeOfActualPool );
2551 : }
2552 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDivideOp ) ;
2553 0 : std::cout << " SgDivideOp has size " << sizeOfActualPool << std::endl;
2554 0 : SgDivideOpStorageClass* SgDivideOpStorageArray = NULL;
2555 0 : if ( 0 < sizeOfActualPool )
2556 : {
2557 0 : SgDivideOpStorageArray = new SgDivideOpStorageClass[sizeOfActualPool] ;
2558 0 : unsigned long storageClassIndex = SgDivideOp::initializeStorageClassArray (SgDivideOpStorageArray); ;
2559 0 : assert ( storageClassIndex == sizeOfActualPool );
2560 : }
2561 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDoWhileStmt ) ;
2562 0 : std::cout << " SgDoWhileStmt has size " << sizeOfActualPool << std::endl;
2563 0 : SgDoWhileStmtStorageClass* SgDoWhileStmtStorageArray = NULL;
2564 0 : if ( 0 < sizeOfActualPool )
2565 : {
2566 0 : SgDoWhileStmtStorageArray = new SgDoWhileStmtStorageClass[sizeOfActualPool] ;
2567 0 : unsigned long storageClassIndex = SgDoWhileStmt::initializeStorageClassArray (SgDoWhileStmtStorageArray); ;
2568 0 : assert ( storageClassIndex == sizeOfActualPool );
2569 : }
2570 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDotExp ) ;
2571 0 : std::cout << " SgDotExp has size " << sizeOfActualPool << std::endl;
2572 0 : SgDotExpStorageClass* SgDotExpStorageArray = NULL;
2573 0 : if ( 0 < sizeOfActualPool )
2574 : {
2575 0 : SgDotExpStorageArray = new SgDotExpStorageClass[sizeOfActualPool] ;
2576 0 : unsigned long storageClassIndex = SgDotExp::initializeStorageClassArray (SgDotExpStorageArray); ;
2577 0 : assert ( storageClassIndex == sizeOfActualPool );
2578 : }
2579 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDotStarOp ) ;
2580 0 : std::cout << " SgDotStarOp has size " << sizeOfActualPool << std::endl;
2581 0 : SgDotStarOpStorageClass* SgDotStarOpStorageArray = NULL;
2582 0 : if ( 0 < sizeOfActualPool )
2583 : {
2584 0 : SgDotStarOpStorageArray = new SgDotStarOpStorageClass[sizeOfActualPool] ;
2585 0 : unsigned long storageClassIndex = SgDotStarOp::initializeStorageClassArray (SgDotStarOpStorageArray); ;
2586 0 : assert ( storageClassIndex == sizeOfActualPool );
2587 : }
2588 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgDoubleVal ) ;
2589 0 : std::cout << " SgDoubleVal has size " << sizeOfActualPool << std::endl;
2590 0 : SgDoubleValStorageClass* SgDoubleValStorageArray = NULL;
2591 0 : if ( 0 < sizeOfActualPool )
2592 : {
2593 0 : SgDoubleValStorageArray = new SgDoubleValStorageClass[sizeOfActualPool] ;
2594 0 : unsigned long storageClassIndex = SgDoubleVal::initializeStorageClassArray (SgDoubleValStorageArray); ;
2595 0 : assert ( storageClassIndex == sizeOfActualPool );
2596 : }
2597 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElaboratedTypeModifier ) ;
2598 0 : std::cout << " SgElaboratedTypeModifier has size " << sizeOfActualPool << std::endl;
2599 0 : SgElaboratedTypeModifierStorageClass* SgElaboratedTypeModifierStorageArray = NULL;
2600 0 : if ( 0 < sizeOfActualPool )
2601 : {
2602 0 : SgElaboratedTypeModifierStorageArray = new SgElaboratedTypeModifierStorageClass[sizeOfActualPool] ;
2603 0 : unsigned long storageClassIndex = SgElaboratedTypeModifier::initializeStorageClassArray (SgElaboratedTypeModifierStorageArray); ;
2604 0 : assert ( storageClassIndex == sizeOfActualPool );
2605 : }
2606 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseOp ) ;
2607 0 : std::cout << " SgElementwiseOp has size " << sizeOfActualPool << std::endl;
2608 0 : SgElementwiseOpStorageClass* SgElementwiseOpStorageArray = NULL;
2609 0 : if ( 0 < sizeOfActualPool )
2610 : {
2611 0 : SgElementwiseOpStorageArray = new SgElementwiseOpStorageClass[sizeOfActualPool] ;
2612 0 : unsigned long storageClassIndex = SgElementwiseOp::initializeStorageClassArray (SgElementwiseOpStorageArray); ;
2613 0 : assert ( storageClassIndex == sizeOfActualPool );
2614 : }
2615 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseAddOp ) ;
2616 0 : std::cout << " SgElementwiseAddOp has size " << sizeOfActualPool << std::endl;
2617 0 : SgElementwiseAddOpStorageClass* SgElementwiseAddOpStorageArray = NULL;
2618 0 : if ( 0 < sizeOfActualPool )
2619 : {
2620 0 : SgElementwiseAddOpStorageArray = new SgElementwiseAddOpStorageClass[sizeOfActualPool] ;
2621 0 : unsigned long storageClassIndex = SgElementwiseAddOp::initializeStorageClassArray (SgElementwiseAddOpStorageArray); ;
2622 0 : assert ( storageClassIndex == sizeOfActualPool );
2623 : }
2624 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseDivideOp ) ;
2625 0 : std::cout << " SgElementwiseDivideOp has size " << sizeOfActualPool << std::endl;
2626 0 : SgElementwiseDivideOpStorageClass* SgElementwiseDivideOpStorageArray = NULL;
2627 0 : if ( 0 < sizeOfActualPool )
2628 : {
2629 0 : SgElementwiseDivideOpStorageArray = new SgElementwiseDivideOpStorageClass[sizeOfActualPool] ;
2630 0 : unsigned long storageClassIndex = SgElementwiseDivideOp::initializeStorageClassArray (SgElementwiseDivideOpStorageArray); ;
2631 0 : assert ( storageClassIndex == sizeOfActualPool );
2632 : }
2633 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseLeftDivideOp ) ;
2634 0 : std::cout << " SgElementwiseLeftDivideOp has size " << sizeOfActualPool << std::endl;
2635 0 : SgElementwiseLeftDivideOpStorageClass* SgElementwiseLeftDivideOpStorageArray = NULL;
2636 0 : if ( 0 < sizeOfActualPool )
2637 : {
2638 0 : SgElementwiseLeftDivideOpStorageArray = new SgElementwiseLeftDivideOpStorageClass[sizeOfActualPool] ;
2639 0 : unsigned long storageClassIndex = SgElementwiseLeftDivideOp::initializeStorageClassArray (SgElementwiseLeftDivideOpStorageArray); ;
2640 0 : assert ( storageClassIndex == sizeOfActualPool );
2641 : }
2642 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseMultiplyOp ) ;
2643 0 : std::cout << " SgElementwiseMultiplyOp has size " << sizeOfActualPool << std::endl;
2644 0 : SgElementwiseMultiplyOpStorageClass* SgElementwiseMultiplyOpStorageArray = NULL;
2645 0 : if ( 0 < sizeOfActualPool )
2646 : {
2647 0 : SgElementwiseMultiplyOpStorageArray = new SgElementwiseMultiplyOpStorageClass[sizeOfActualPool] ;
2648 0 : unsigned long storageClassIndex = SgElementwiseMultiplyOp::initializeStorageClassArray (SgElementwiseMultiplyOpStorageArray); ;
2649 0 : assert ( storageClassIndex == sizeOfActualPool );
2650 : }
2651 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwisePowerOp ) ;
2652 0 : std::cout << " SgElementwisePowerOp has size " << sizeOfActualPool << std::endl;
2653 0 : SgElementwisePowerOpStorageClass* SgElementwisePowerOpStorageArray = NULL;
2654 0 : if ( 0 < sizeOfActualPool )
2655 : {
2656 0 : SgElementwisePowerOpStorageArray = new SgElementwisePowerOpStorageClass[sizeOfActualPool] ;
2657 0 : unsigned long storageClassIndex = SgElementwisePowerOp::initializeStorageClassArray (SgElementwisePowerOpStorageArray); ;
2658 0 : assert ( storageClassIndex == sizeOfActualPool );
2659 : }
2660 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElementwiseSubtractOp ) ;
2661 0 : std::cout << " SgElementwiseSubtractOp has size " << sizeOfActualPool << std::endl;
2662 0 : SgElementwiseSubtractOpStorageClass* SgElementwiseSubtractOpStorageArray = NULL;
2663 0 : if ( 0 < sizeOfActualPool )
2664 : {
2665 0 : SgElementwiseSubtractOpStorageArray = new SgElementwiseSubtractOpStorageClass[sizeOfActualPool] ;
2666 0 : unsigned long storageClassIndex = SgElementwiseSubtractOp::initializeStorageClassArray (SgElementwiseSubtractOpStorageArray); ;
2667 0 : assert ( storageClassIndex == sizeOfActualPool );
2668 : }
2669 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElseDirectiveStatement ) ;
2670 0 : std::cout << " SgElseDirectiveStatement has size " << sizeOfActualPool << std::endl;
2671 0 : SgElseDirectiveStatementStorageClass* SgElseDirectiveStatementStorageArray = NULL;
2672 0 : if ( 0 < sizeOfActualPool )
2673 : {
2674 0 : SgElseDirectiveStatementStorageArray = new SgElseDirectiveStatementStorageClass[sizeOfActualPool] ;
2675 0 : unsigned long storageClassIndex = SgElseDirectiveStatement::initializeStorageClassArray (SgElseDirectiveStatementStorageArray); ;
2676 0 : assert ( storageClassIndex == sizeOfActualPool );
2677 : }
2678 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElseWhereStatement ) ;
2679 0 : std::cout << " SgElseWhereStatement has size " << sizeOfActualPool << std::endl;
2680 0 : SgElseWhereStatementStorageClass* SgElseWhereStatementStorageArray = NULL;
2681 0 : if ( 0 < sizeOfActualPool )
2682 : {
2683 0 : SgElseWhereStatementStorageArray = new SgElseWhereStatementStorageClass[sizeOfActualPool] ;
2684 0 : unsigned long storageClassIndex = SgElseWhereStatement::initializeStorageClassArray (SgElseWhereStatementStorageArray); ;
2685 0 : assert ( storageClassIndex == sizeOfActualPool );
2686 : }
2687 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgElseifDirectiveStatement ) ;
2688 0 : std::cout << " SgElseifDirectiveStatement has size " << sizeOfActualPool << std::endl;
2689 0 : SgElseifDirectiveStatementStorageClass* SgElseifDirectiveStatementStorageArray = NULL;
2690 0 : if ( 0 < sizeOfActualPool )
2691 : {
2692 0 : SgElseifDirectiveStatementStorageArray = new SgElseifDirectiveStatementStorageClass[sizeOfActualPool] ;
2693 0 : unsigned long storageClassIndex = SgElseifDirectiveStatement::initializeStorageClassArray (SgElseifDirectiveStatementStorageArray); ;
2694 0 : assert ( storageClassIndex == sizeOfActualPool );
2695 : }
2696 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEmptyDeclaration ) ;
2697 0 : std::cout << " SgEmptyDeclaration has size " << sizeOfActualPool << std::endl;
2698 0 : SgEmptyDeclarationStorageClass* SgEmptyDeclarationStorageArray = NULL;
2699 0 : if ( 0 < sizeOfActualPool )
2700 : {
2701 0 : SgEmptyDeclarationStorageArray = new SgEmptyDeclarationStorageClass[sizeOfActualPool] ;
2702 0 : unsigned long storageClassIndex = SgEmptyDeclaration::initializeStorageClassArray (SgEmptyDeclarationStorageArray); ;
2703 0 : assert ( storageClassIndex == sizeOfActualPool );
2704 : }
2705 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEmptyDirectiveStatement ) ;
2706 0 : std::cout << " SgEmptyDirectiveStatement has size " << sizeOfActualPool << std::endl;
2707 0 : SgEmptyDirectiveStatementStorageClass* SgEmptyDirectiveStatementStorageArray = NULL;
2708 0 : if ( 0 < sizeOfActualPool )
2709 : {
2710 0 : SgEmptyDirectiveStatementStorageArray = new SgEmptyDirectiveStatementStorageClass[sizeOfActualPool] ;
2711 0 : unsigned long storageClassIndex = SgEmptyDirectiveStatement::initializeStorageClassArray (SgEmptyDirectiveStatementStorageArray); ;
2712 0 : assert ( storageClassIndex == sizeOfActualPool );
2713 : }
2714 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEndfileStatement ) ;
2715 0 : std::cout << " SgEndfileStatement has size " << sizeOfActualPool << std::endl;
2716 0 : SgEndfileStatementStorageClass* SgEndfileStatementStorageArray = NULL;
2717 0 : if ( 0 < sizeOfActualPool )
2718 : {
2719 0 : SgEndfileStatementStorageArray = new SgEndfileStatementStorageClass[sizeOfActualPool] ;
2720 0 : unsigned long storageClassIndex = SgEndfileStatement::initializeStorageClassArray (SgEndfileStatementStorageArray); ;
2721 0 : assert ( storageClassIndex == sizeOfActualPool );
2722 : }
2723 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEndifDirectiveStatement ) ;
2724 0 : std::cout << " SgEndifDirectiveStatement has size " << sizeOfActualPool << std::endl;
2725 0 : SgEndifDirectiveStatementStorageClass* SgEndifDirectiveStatementStorageArray = NULL;
2726 0 : if ( 0 < sizeOfActualPool )
2727 : {
2728 0 : SgEndifDirectiveStatementStorageArray = new SgEndifDirectiveStatementStorageClass[sizeOfActualPool] ;
2729 0 : unsigned long storageClassIndex = SgEndifDirectiveStatement::initializeStorageClassArray (SgEndifDirectiveStatementStorageArray); ;
2730 0 : assert ( storageClassIndex == sizeOfActualPool );
2731 : }
2732 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEntryStatement ) ;
2733 0 : std::cout << " SgEntryStatement has size " << sizeOfActualPool << std::endl;
2734 0 : SgEntryStatementStorageClass* SgEntryStatementStorageArray = NULL;
2735 0 : if ( 0 < sizeOfActualPool )
2736 : {
2737 0 : SgEntryStatementStorageArray = new SgEntryStatementStorageClass[sizeOfActualPool] ;
2738 0 : unsigned long storageClassIndex = SgEntryStatement::initializeStorageClassArray (SgEntryStatementStorageArray); ;
2739 0 : assert ( storageClassIndex == sizeOfActualPool );
2740 : }
2741 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEnumDeclaration ) ;
2742 0 : std::cout << " SgEnumDeclaration has size " << sizeOfActualPool << std::endl;
2743 0 : SgEnumDeclarationStorageClass* SgEnumDeclarationStorageArray = NULL;
2744 0 : if ( 0 < sizeOfActualPool )
2745 : {
2746 0 : SgEnumDeclarationStorageArray = new SgEnumDeclarationStorageClass[sizeOfActualPool] ;
2747 0 : unsigned long storageClassIndex = SgEnumDeclaration::initializeStorageClassArray (SgEnumDeclarationStorageArray); ;
2748 0 : assert ( storageClassIndex == sizeOfActualPool );
2749 : }
2750 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEnumFieldSymbol ) ;
2751 0 : std::cout << " SgEnumFieldSymbol has size " << sizeOfActualPool << std::endl;
2752 0 : SgEnumFieldSymbolStorageClass* SgEnumFieldSymbolStorageArray = NULL;
2753 0 : if ( 0 < sizeOfActualPool )
2754 : {
2755 0 : SgEnumFieldSymbolStorageArray = new SgEnumFieldSymbolStorageClass[sizeOfActualPool] ;
2756 0 : unsigned long storageClassIndex = SgEnumFieldSymbol::initializeStorageClassArray (SgEnumFieldSymbolStorageArray); ;
2757 0 : assert ( storageClassIndex == sizeOfActualPool );
2758 : }
2759 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEnumSymbol ) ;
2760 0 : std::cout << " SgEnumSymbol has size " << sizeOfActualPool << std::endl;
2761 0 : SgEnumSymbolStorageClass* SgEnumSymbolStorageArray = NULL;
2762 0 : if ( 0 < sizeOfActualPool )
2763 : {
2764 0 : SgEnumSymbolStorageArray = new SgEnumSymbolStorageClass[sizeOfActualPool] ;
2765 0 : unsigned long storageClassIndex = SgEnumSymbol::initializeStorageClassArray (SgEnumSymbolStorageArray); ;
2766 0 : assert ( storageClassIndex == sizeOfActualPool );
2767 : }
2768 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEnumType ) ;
2769 0 : std::cout << " SgEnumType has size " << sizeOfActualPool << std::endl;
2770 0 : SgEnumTypeStorageClass* SgEnumTypeStorageArray = NULL;
2771 0 : if ( 0 < sizeOfActualPool )
2772 : {
2773 0 : SgEnumTypeStorageArray = new SgEnumTypeStorageClass[sizeOfActualPool] ;
2774 0 : unsigned long storageClassIndex = SgEnumType::initializeStorageClassArray (SgEnumTypeStorageArray); ;
2775 0 : assert ( storageClassIndex == sizeOfActualPool );
2776 : }
2777 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEnumVal ) ;
2778 0 : std::cout << " SgEnumVal has size " << sizeOfActualPool << std::endl;
2779 0 : SgEnumValStorageClass* SgEnumValStorageArray = NULL;
2780 0 : if ( 0 < sizeOfActualPool )
2781 : {
2782 0 : SgEnumValStorageArray = new SgEnumValStorageClass[sizeOfActualPool] ;
2783 0 : unsigned long storageClassIndex = SgEnumVal::initializeStorageClassArray (SgEnumValStorageArray); ;
2784 0 : assert ( storageClassIndex == sizeOfActualPool );
2785 : }
2786 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEqualityOp ) ;
2787 0 : std::cout << " SgEqualityOp has size " << sizeOfActualPool << std::endl;
2788 0 : SgEqualityOpStorageClass* SgEqualityOpStorageArray = NULL;
2789 0 : if ( 0 < sizeOfActualPool )
2790 : {
2791 0 : SgEqualityOpStorageArray = new SgEqualityOpStorageClass[sizeOfActualPool] ;
2792 0 : unsigned long storageClassIndex = SgEqualityOp::initializeStorageClassArray (SgEqualityOpStorageArray); ;
2793 0 : assert ( storageClassIndex == sizeOfActualPool );
2794 : }
2795 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgEquivalenceStatement ) ;
2796 0 : std::cout << " SgEquivalenceStatement has size " << sizeOfActualPool << std::endl;
2797 0 : SgEquivalenceStatementStorageClass* SgEquivalenceStatementStorageArray = NULL;
2798 0 : if ( 0 < sizeOfActualPool )
2799 : {
2800 0 : SgEquivalenceStatementStorageArray = new SgEquivalenceStatementStorageClass[sizeOfActualPool] ;
2801 0 : unsigned long storageClassIndex = SgEquivalenceStatement::initializeStorageClassArray (SgEquivalenceStatementStorageArray); ;
2802 0 : assert ( storageClassIndex == sizeOfActualPool );
2803 : }
2804 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgErrorDirectiveStatement ) ;
2805 0 : std::cout << " SgErrorDirectiveStatement has size " << sizeOfActualPool << std::endl;
2806 0 : SgErrorDirectiveStatementStorageClass* SgErrorDirectiveStatementStorageArray = NULL;
2807 0 : if ( 0 < sizeOfActualPool )
2808 : {
2809 0 : SgErrorDirectiveStatementStorageArray = new SgErrorDirectiveStatementStorageClass[sizeOfActualPool] ;
2810 0 : unsigned long storageClassIndex = SgErrorDirectiveStatement::initializeStorageClassArray (SgErrorDirectiveStatementStorageArray); ;
2811 0 : assert ( storageClassIndex == sizeOfActualPool );
2812 : }
2813 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExecStatement ) ;
2814 0 : std::cout << " SgExecStatement has size " << sizeOfActualPool << std::endl;
2815 0 : SgExecStatementStorageClass* SgExecStatementStorageArray = NULL;
2816 0 : if ( 0 < sizeOfActualPool )
2817 : {
2818 0 : SgExecStatementStorageArray = new SgExecStatementStorageClass[sizeOfActualPool] ;
2819 0 : unsigned long storageClassIndex = SgExecStatement::initializeStorageClassArray (SgExecStatementStorageArray); ;
2820 0 : assert ( storageClassIndex == sizeOfActualPool );
2821 : }
2822 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExponentiationOp ) ;
2823 0 : std::cout << " SgExponentiationOp has size " << sizeOfActualPool << std::endl;
2824 0 : SgExponentiationOpStorageClass* SgExponentiationOpStorageArray = NULL;
2825 0 : if ( 0 < sizeOfActualPool )
2826 : {
2827 0 : SgExponentiationOpStorageArray = new SgExponentiationOpStorageClass[sizeOfActualPool] ;
2828 0 : unsigned long storageClassIndex = SgExponentiationOp::initializeStorageClassArray (SgExponentiationOpStorageArray); ;
2829 0 : assert ( storageClassIndex == sizeOfActualPool );
2830 : }
2831 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExponentiationAssignOp ) ;
2832 0 : std::cout << " SgExponentiationAssignOp has size " << sizeOfActualPool << std::endl;
2833 0 : SgExponentiationAssignOpStorageClass* SgExponentiationAssignOpStorageArray = NULL;
2834 0 : if ( 0 < sizeOfActualPool )
2835 : {
2836 0 : SgExponentiationAssignOpStorageArray = new SgExponentiationAssignOpStorageClass[sizeOfActualPool] ;
2837 0 : unsigned long storageClassIndex = SgExponentiationAssignOp::initializeStorageClassArray (SgExponentiationAssignOpStorageArray); ;
2838 0 : assert ( storageClassIndex == sizeOfActualPool );
2839 : }
2840 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExprListExp ) ;
2841 0 : std::cout << " SgExprListExp has size " << sizeOfActualPool << std::endl;
2842 0 : SgExprListExpStorageClass* SgExprListExpStorageArray = NULL;
2843 0 : if ( 0 < sizeOfActualPool )
2844 : {
2845 0 : SgExprListExpStorageArray = new SgExprListExpStorageClass[sizeOfActualPool] ;
2846 0 : unsigned long storageClassIndex = SgExprListExp::initializeStorageClassArray (SgExprListExpStorageArray); ;
2847 0 : assert ( storageClassIndex == sizeOfActualPool );
2848 : }
2849 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExprStatement ) ;
2850 0 : std::cout << " SgExprStatement has size " << sizeOfActualPool << std::endl;
2851 0 : SgExprStatementStorageClass* SgExprStatementStorageArray = NULL;
2852 0 : if ( 0 < sizeOfActualPool )
2853 : {
2854 0 : SgExprStatementStorageArray = new SgExprStatementStorageClass[sizeOfActualPool] ;
2855 0 : unsigned long storageClassIndex = SgExprStatement::initializeStorageClassArray (SgExprStatementStorageArray); ;
2856 0 : assert ( storageClassIndex == sizeOfActualPool );
2857 : }
2858 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExpression ) ;
2859 0 : std::cout << " SgExpression has size " << sizeOfActualPool << std::endl;
2860 0 : SgExpressionStorageClass* SgExpressionStorageArray = NULL;
2861 0 : if ( 0 < sizeOfActualPool )
2862 : {
2863 0 : SgExpressionStorageArray = new SgExpressionStorageClass[sizeOfActualPool] ;
2864 0 : unsigned long storageClassIndex = SgExpression::initializeStorageClassArray (SgExpressionStorageArray); ;
2865 0 : assert ( storageClassIndex == sizeOfActualPool );
2866 : }
2867 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgExpressionRoot ) ;
2868 0 : std::cout << " SgExpressionRoot has size " << sizeOfActualPool << std::endl;
2869 0 : SgExpressionRootStorageClass* SgExpressionRootStorageArray = NULL;
2870 0 : if ( 0 < sizeOfActualPool )
2871 : {
2872 0 : SgExpressionRootStorageArray = new SgExpressionRootStorageClass[sizeOfActualPool] ;
2873 0 : unsigned long storageClassIndex = SgExpressionRoot::initializeStorageClassArray (SgExpressionRootStorageArray); ;
2874 0 : assert ( storageClassIndex == sizeOfActualPool );
2875 : }
2876 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFile ) ;
2877 0 : std::cout << " SgFile has size " << sizeOfActualPool << std::endl;
2878 0 : SgFileStorageClass* SgFileStorageArray = NULL;
2879 0 : if ( 0 < sizeOfActualPool )
2880 : {
2881 0 : SgFileStorageArray = new SgFileStorageClass[sizeOfActualPool] ;
2882 0 : unsigned long storageClassIndex = SgFile::initializeStorageClassArray (SgFileStorageArray); ;
2883 0 : assert ( storageClassIndex == sizeOfActualPool );
2884 : }
2885 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFileList ) ;
2886 0 : std::cout << " SgFileList has size " << sizeOfActualPool << std::endl;
2887 0 : SgFileListStorageClass* SgFileListStorageArray = NULL;
2888 0 : if ( 0 < sizeOfActualPool )
2889 : {
2890 0 : SgFileListStorageArray = new SgFileListStorageClass[sizeOfActualPool] ;
2891 0 : unsigned long storageClassIndex = SgFileList::initializeStorageClassArray (SgFileListStorageArray); ;
2892 0 : assert ( storageClassIndex == sizeOfActualPool );
2893 : }
2894 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFloatVal ) ;
2895 0 : std::cout << " SgFloatVal has size " << sizeOfActualPool << std::endl;
2896 0 : SgFloatValStorageClass* SgFloatValStorageArray = NULL;
2897 0 : if ( 0 < sizeOfActualPool )
2898 : {
2899 0 : SgFloatValStorageArray = new SgFloatValStorageClass[sizeOfActualPool] ;
2900 0 : unsigned long storageClassIndex = SgFloatVal::initializeStorageClassArray (SgFloatValStorageArray); ;
2901 0 : assert ( storageClassIndex == sizeOfActualPool );
2902 : }
2903 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFloat128Val ) ;
2904 0 : std::cout << " SgFloat128Val has size " << sizeOfActualPool << std::endl;
2905 0 : SgFloat128ValStorageClass* SgFloat128ValStorageArray = NULL;
2906 0 : if ( 0 < sizeOfActualPool )
2907 : {
2908 0 : SgFloat128ValStorageArray = new SgFloat128ValStorageClass[sizeOfActualPool] ;
2909 0 : unsigned long storageClassIndex = SgFloat128Val::initializeStorageClassArray (SgFloat128ValStorageArray); ;
2910 0 : assert ( storageClassIndex == sizeOfActualPool );
2911 : }
2912 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFloat80Val ) ;
2913 0 : std::cout << " SgFloat80Val has size " << sizeOfActualPool << std::endl;
2914 0 : SgFloat80ValStorageClass* SgFloat80ValStorageArray = NULL;
2915 0 : if ( 0 < sizeOfActualPool )
2916 : {
2917 0 : SgFloat80ValStorageArray = new SgFloat80ValStorageClass[sizeOfActualPool] ;
2918 0 : unsigned long storageClassIndex = SgFloat80Val::initializeStorageClassArray (SgFloat80ValStorageArray); ;
2919 0 : assert ( storageClassIndex == sizeOfActualPool );
2920 : }
2921 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFoldExpression ) ;
2922 0 : std::cout << " SgFoldExpression has size " << sizeOfActualPool << std::endl;
2923 0 : SgFoldExpressionStorageClass* SgFoldExpressionStorageArray = NULL;
2924 0 : if ( 0 < sizeOfActualPool )
2925 : {
2926 0 : SgFoldExpressionStorageArray = new SgFoldExpressionStorageClass[sizeOfActualPool] ;
2927 0 : unsigned long storageClassIndex = SgFoldExpression::initializeStorageClassArray (SgFoldExpressionStorageArray); ;
2928 0 : assert ( storageClassIndex == sizeOfActualPool );
2929 : }
2930 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFlushStatement ) ;
2931 0 : std::cout << " SgFlushStatement has size " << sizeOfActualPool << std::endl;
2932 0 : SgFlushStatementStorageClass* SgFlushStatementStorageArray = NULL;
2933 0 : if ( 0 < sizeOfActualPool )
2934 : {
2935 0 : SgFlushStatementStorageArray = new SgFlushStatementStorageClass[sizeOfActualPool] ;
2936 0 : unsigned long storageClassIndex = SgFlushStatement::initializeStorageClassArray (SgFlushStatementStorageArray); ;
2937 0 : assert ( storageClassIndex == sizeOfActualPool );
2938 : }
2939 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgForAllStatement ) ;
2940 0 : std::cout << " SgForAllStatement has size " << sizeOfActualPool << std::endl;
2941 0 : SgForAllStatementStorageClass* SgForAllStatementStorageArray = NULL;
2942 0 : if ( 0 < sizeOfActualPool )
2943 : {
2944 0 : SgForAllStatementStorageArray = new SgForAllStatementStorageClass[sizeOfActualPool] ;
2945 0 : unsigned long storageClassIndex = SgForAllStatement::initializeStorageClassArray (SgForAllStatementStorageArray); ;
2946 0 : assert ( storageClassIndex == sizeOfActualPool );
2947 : }
2948 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgForInitStatement ) ;
2949 0 : std::cout << " SgForInitStatement has size " << sizeOfActualPool << std::endl;
2950 0 : SgForInitStatementStorageClass* SgForInitStatementStorageArray = NULL;
2951 0 : if ( 0 < sizeOfActualPool )
2952 : {
2953 0 : SgForInitStatementStorageArray = new SgForInitStatementStorageClass[sizeOfActualPool] ;
2954 0 : unsigned long storageClassIndex = SgForInitStatement::initializeStorageClassArray (SgForInitStatementStorageArray); ;
2955 0 : assert ( storageClassIndex == sizeOfActualPool );
2956 : }
2957 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgForStatement ) ;
2958 0 : std::cout << " SgForStatement has size " << sizeOfActualPool << std::endl;
2959 0 : SgForStatementStorageClass* SgForStatementStorageArray = NULL;
2960 0 : if ( 0 < sizeOfActualPool )
2961 : {
2962 0 : SgForStatementStorageArray = new SgForStatementStorageClass[sizeOfActualPool] ;
2963 0 : unsigned long storageClassIndex = SgForStatement::initializeStorageClassArray (SgForStatementStorageArray); ;
2964 0 : assert ( storageClassIndex == sizeOfActualPool );
2965 : }
2966 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFormatItem ) ;
2967 0 : std::cout << " SgFormatItem has size " << sizeOfActualPool << std::endl;
2968 0 : SgFormatItemStorageClass* SgFormatItemStorageArray = NULL;
2969 0 : if ( 0 < sizeOfActualPool )
2970 : {
2971 0 : SgFormatItemStorageArray = new SgFormatItemStorageClass[sizeOfActualPool] ;
2972 0 : unsigned long storageClassIndex = SgFormatItem::initializeStorageClassArray (SgFormatItemStorageArray); ;
2973 0 : assert ( storageClassIndex == sizeOfActualPool );
2974 : }
2975 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFormatItemList ) ;
2976 0 : std::cout << " SgFormatItemList has size " << sizeOfActualPool << std::endl;
2977 0 : SgFormatItemListStorageClass* SgFormatItemListStorageArray = NULL;
2978 0 : if ( 0 < sizeOfActualPool )
2979 : {
2980 0 : SgFormatItemListStorageArray = new SgFormatItemListStorageClass[sizeOfActualPool] ;
2981 0 : unsigned long storageClassIndex = SgFormatItemList::initializeStorageClassArray (SgFormatItemListStorageArray); ;
2982 0 : assert ( storageClassIndex == sizeOfActualPool );
2983 : }
2984 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFormatStatement ) ;
2985 0 : std::cout << " SgFormatStatement has size " << sizeOfActualPool << std::endl;
2986 0 : SgFormatStatementStorageClass* SgFormatStatementStorageArray = NULL;
2987 0 : if ( 0 < sizeOfActualPool )
2988 : {
2989 0 : SgFormatStatementStorageArray = new SgFormatStatementStorageClass[sizeOfActualPool] ;
2990 0 : unsigned long storageClassIndex = SgFormatStatement::initializeStorageClassArray (SgFormatStatementStorageArray); ;
2991 0 : assert ( storageClassIndex == sizeOfActualPool );
2992 : }
2993 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFortranDo ) ;
2994 0 : std::cout << " SgFortranDo has size " << sizeOfActualPool << std::endl;
2995 0 : SgFortranDoStorageClass* SgFortranDoStorageArray = NULL;
2996 0 : if ( 0 < sizeOfActualPool )
2997 : {
2998 0 : SgFortranDoStorageArray = new SgFortranDoStorageClass[sizeOfActualPool] ;
2999 0 : unsigned long storageClassIndex = SgFortranDo::initializeStorageClassArray (SgFortranDoStorageArray); ;
3000 0 : assert ( storageClassIndex == sizeOfActualPool );
3001 : }
3002 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFortranIncludeLine ) ;
3003 0 : std::cout << " SgFortranIncludeLine has size " << sizeOfActualPool << std::endl;
3004 0 : SgFortranIncludeLineStorageClass* SgFortranIncludeLineStorageArray = NULL;
3005 0 : if ( 0 < sizeOfActualPool )
3006 : {
3007 0 : SgFortranIncludeLineStorageArray = new SgFortranIncludeLineStorageClass[sizeOfActualPool] ;
3008 0 : unsigned long storageClassIndex = SgFortranIncludeLine::initializeStorageClassArray (SgFortranIncludeLineStorageArray); ;
3009 0 : assert ( storageClassIndex == sizeOfActualPool );
3010 : }
3011 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFortranNonblockedDo ) ;
3012 0 : std::cout << " SgFortranNonblockedDo has size " << sizeOfActualPool << std::endl;
3013 0 : SgFortranNonblockedDoStorageClass* SgFortranNonblockedDoStorageArray = NULL;
3014 0 : if ( 0 < sizeOfActualPool )
3015 : {
3016 0 : SgFortranNonblockedDoStorageArray = new SgFortranNonblockedDoStorageClass[sizeOfActualPool] ;
3017 0 : unsigned long storageClassIndex = SgFortranNonblockedDo::initializeStorageClassArray (SgFortranNonblockedDoStorageArray); ;
3018 0 : assert ( storageClassIndex == sizeOfActualPool );
3019 : }
3020 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFuncDecl_attr ) ;
3021 0 : std::cout << " SgFuncDecl_attr has size " << sizeOfActualPool << std::endl;
3022 0 : SgFuncDecl_attrStorageClass* SgFuncDecl_attrStorageArray = NULL;
3023 0 : if ( 0 < sizeOfActualPool )
3024 : {
3025 0 : SgFuncDecl_attrStorageArray = new SgFuncDecl_attrStorageClass[sizeOfActualPool] ;
3026 0 : unsigned long storageClassIndex = SgFuncDecl_attr::initializeStorageClassArray (SgFuncDecl_attrStorageArray); ;
3027 0 : assert ( storageClassIndex == sizeOfActualPool );
3028 : }
3029 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionCallExp ) ;
3030 0 : std::cout << " SgFunctionCallExp has size " << sizeOfActualPool << std::endl;
3031 0 : SgFunctionCallExpStorageClass* SgFunctionCallExpStorageArray = NULL;
3032 0 : if ( 0 < sizeOfActualPool )
3033 : {
3034 0 : SgFunctionCallExpStorageArray = new SgFunctionCallExpStorageClass[sizeOfActualPool] ;
3035 0 : unsigned long storageClassIndex = SgFunctionCallExp::initializeStorageClassArray (SgFunctionCallExpStorageArray); ;
3036 0 : assert ( storageClassIndex == sizeOfActualPool );
3037 : }
3038 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionDeclaration ) ;
3039 0 : std::cout << " SgFunctionDeclaration has size " << sizeOfActualPool << std::endl;
3040 0 : SgFunctionDeclarationStorageClass* SgFunctionDeclarationStorageArray = NULL;
3041 0 : if ( 0 < sizeOfActualPool )
3042 : {
3043 0 : SgFunctionDeclarationStorageArray = new SgFunctionDeclarationStorageClass[sizeOfActualPool] ;
3044 0 : unsigned long storageClassIndex = SgFunctionDeclaration::initializeStorageClassArray (SgFunctionDeclarationStorageArray); ;
3045 0 : assert ( storageClassIndex == sizeOfActualPool );
3046 : }
3047 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionDefinition ) ;
3048 0 : std::cout << " SgFunctionDefinition has size " << sizeOfActualPool << std::endl;
3049 0 : SgFunctionDefinitionStorageClass* SgFunctionDefinitionStorageArray = NULL;
3050 0 : if ( 0 < sizeOfActualPool )
3051 : {
3052 0 : SgFunctionDefinitionStorageArray = new SgFunctionDefinitionStorageClass[sizeOfActualPool] ;
3053 0 : unsigned long storageClassIndex = SgFunctionDefinition::initializeStorageClassArray (SgFunctionDefinitionStorageArray); ;
3054 0 : assert ( storageClassIndex == sizeOfActualPool );
3055 : }
3056 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionParameterScope ) ;
3057 0 : std::cout << " SgFunctionParameterScope has size " << sizeOfActualPool << std::endl;
3058 0 : SgFunctionParameterScopeStorageClass* SgFunctionParameterScopeStorageArray = NULL;
3059 0 : if ( 0 < sizeOfActualPool )
3060 : {
3061 0 : SgFunctionParameterScopeStorageArray = new SgFunctionParameterScopeStorageClass[sizeOfActualPool] ;
3062 0 : unsigned long storageClassIndex = SgFunctionParameterScope::initializeStorageClassArray (SgFunctionParameterScopeStorageArray); ;
3063 0 : assert ( storageClassIndex == sizeOfActualPool );
3064 : }
3065 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionModifier ) ;
3066 0 : std::cout << " SgFunctionModifier has size " << sizeOfActualPool << std::endl;
3067 0 : SgFunctionModifierStorageClass* SgFunctionModifierStorageArray = NULL;
3068 0 : if ( 0 < sizeOfActualPool )
3069 : {
3070 0 : SgFunctionModifierStorageArray = new SgFunctionModifierStorageClass[sizeOfActualPool] ;
3071 0 : unsigned long storageClassIndex = SgFunctionModifier::initializeStorageClassArray (SgFunctionModifierStorageArray); ;
3072 0 : assert ( storageClassIndex == sizeOfActualPool );
3073 : }
3074 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionParameterList ) ;
3075 0 : std::cout << " SgFunctionParameterList has size " << sizeOfActualPool << std::endl;
3076 0 : SgFunctionParameterListStorageClass* SgFunctionParameterListStorageArray = NULL;
3077 0 : if ( 0 < sizeOfActualPool )
3078 : {
3079 0 : SgFunctionParameterListStorageArray = new SgFunctionParameterListStorageClass[sizeOfActualPool] ;
3080 0 : unsigned long storageClassIndex = SgFunctionParameterList::initializeStorageClassArray (SgFunctionParameterListStorageArray); ;
3081 0 : assert ( storageClassIndex == sizeOfActualPool );
3082 : }
3083 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionParameterRefExp ) ;
3084 0 : std::cout << " SgFunctionParameterRefExp has size " << sizeOfActualPool << std::endl;
3085 0 : SgFunctionParameterRefExpStorageClass* SgFunctionParameterRefExpStorageArray = NULL;
3086 0 : if ( 0 < sizeOfActualPool )
3087 : {
3088 0 : SgFunctionParameterRefExpStorageArray = new SgFunctionParameterRefExpStorageClass[sizeOfActualPool] ;
3089 0 : unsigned long storageClassIndex = SgFunctionParameterRefExp::initializeStorageClassArray (SgFunctionParameterRefExpStorageArray); ;
3090 0 : assert ( storageClassIndex == sizeOfActualPool );
3091 : }
3092 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionParameterTypeList ) ;
3093 0 : std::cout << " SgFunctionParameterTypeList has size " << sizeOfActualPool << std::endl;
3094 0 : SgFunctionParameterTypeListStorageClass* SgFunctionParameterTypeListStorageArray = NULL;
3095 0 : if ( 0 < sizeOfActualPool )
3096 : {
3097 0 : SgFunctionParameterTypeListStorageArray = new SgFunctionParameterTypeListStorageClass[sizeOfActualPool] ;
3098 0 : unsigned long storageClassIndex = SgFunctionParameterTypeList::initializeStorageClassArray (SgFunctionParameterTypeListStorageArray); ;
3099 0 : assert ( storageClassIndex == sizeOfActualPool );
3100 : }
3101 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionRefExp ) ;
3102 0 : std::cout << " SgFunctionRefExp has size " << sizeOfActualPool << std::endl;
3103 0 : SgFunctionRefExpStorageClass* SgFunctionRefExpStorageArray = NULL;
3104 0 : if ( 0 < sizeOfActualPool )
3105 : {
3106 0 : SgFunctionRefExpStorageArray = new SgFunctionRefExpStorageClass[sizeOfActualPool] ;
3107 0 : unsigned long storageClassIndex = SgFunctionRefExp::initializeStorageClassArray (SgFunctionRefExpStorageArray); ;
3108 0 : assert ( storageClassIndex == sizeOfActualPool );
3109 : }
3110 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionSymbol ) ;
3111 0 : std::cout << " SgFunctionSymbol has size " << sizeOfActualPool << std::endl;
3112 0 : SgFunctionSymbolStorageClass* SgFunctionSymbolStorageArray = NULL;
3113 0 : if ( 0 < sizeOfActualPool )
3114 : {
3115 0 : SgFunctionSymbolStorageArray = new SgFunctionSymbolStorageClass[sizeOfActualPool] ;
3116 0 : unsigned long storageClassIndex = SgFunctionSymbol::initializeStorageClassArray (SgFunctionSymbolStorageArray); ;
3117 0 : assert ( storageClassIndex == sizeOfActualPool );
3118 : }
3119 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionType ) ;
3120 0 : std::cout << " SgFunctionType has size " << sizeOfActualPool << std::endl;
3121 0 : SgFunctionTypeStorageClass* SgFunctionTypeStorageArray = NULL;
3122 0 : if ( 0 < sizeOfActualPool )
3123 : {
3124 0 : SgFunctionTypeStorageArray = new SgFunctionTypeStorageClass[sizeOfActualPool] ;
3125 0 : unsigned long storageClassIndex = SgFunctionType::initializeStorageClassArray (SgFunctionTypeStorageArray); ;
3126 0 : assert ( storageClassIndex == sizeOfActualPool );
3127 : }
3128 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionTypeSymbol ) ;
3129 0 : std::cout << " SgFunctionTypeSymbol has size " << sizeOfActualPool << std::endl;
3130 0 : SgFunctionTypeSymbolStorageClass* SgFunctionTypeSymbolStorageArray = NULL;
3131 0 : if ( 0 < sizeOfActualPool )
3132 : {
3133 0 : SgFunctionTypeSymbolStorageArray = new SgFunctionTypeSymbolStorageClass[sizeOfActualPool] ;
3134 0 : unsigned long storageClassIndex = SgFunctionTypeSymbol::initializeStorageClassArray (SgFunctionTypeSymbolStorageArray); ;
3135 0 : assert ( storageClassIndex == sizeOfActualPool );
3136 : }
3137 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgFunctionTypeTable ) ;
3138 0 : std::cout << " SgFunctionTypeTable has size " << sizeOfActualPool << std::endl;
3139 0 : SgFunctionTypeTableStorageClass* SgFunctionTypeTableStorageArray = NULL;
3140 0 : if ( 0 < sizeOfActualPool )
3141 : {
3142 0 : SgFunctionTypeTableStorageArray = new SgFunctionTypeTableStorageClass[sizeOfActualPool] ;
3143 0 : unsigned long storageClassIndex = SgFunctionTypeTable::initializeStorageClassArray (SgFunctionTypeTableStorageArray); ;
3144 0 : assert ( storageClassIndex == sizeOfActualPool );
3145 : }
3146 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeTable ) ;
3147 0 : std::cout << " SgTypeTable has size " << sizeOfActualPool << std::endl;
3148 0 : SgTypeTableStorageClass* SgTypeTableStorageArray = NULL;
3149 0 : if ( 0 < sizeOfActualPool )
3150 : {
3151 0 : SgTypeTableStorageArray = new SgTypeTableStorageClass[sizeOfActualPool] ;
3152 0 : unsigned long storageClassIndex = SgTypeTable::initializeStorageClassArray (SgTypeTableStorageArray); ;
3153 0 : assert ( storageClassIndex == sizeOfActualPool );
3154 : }
3155 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGlobal ) ;
3156 0 : std::cout << " SgGlobal has size " << sizeOfActualPool << std::endl;
3157 0 : SgGlobalStorageClass* SgGlobalStorageArray = NULL;
3158 0 : if ( 0 < sizeOfActualPool )
3159 : {
3160 0 : SgGlobalStorageArray = new SgGlobalStorageClass[sizeOfActualPool] ;
3161 0 : unsigned long storageClassIndex = SgGlobal::initializeStorageClassArray (SgGlobalStorageArray); ;
3162 0 : assert ( storageClassIndex == sizeOfActualPool );
3163 : }
3164 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGotoStatement ) ;
3165 0 : std::cout << " SgGotoStatement has size " << sizeOfActualPool << std::endl;
3166 0 : SgGotoStatementStorageClass* SgGotoStatementStorageArray = NULL;
3167 0 : if ( 0 < sizeOfActualPool )
3168 : {
3169 0 : SgGotoStatementStorageArray = new SgGotoStatementStorageClass[sizeOfActualPool] ;
3170 0 : unsigned long storageClassIndex = SgGotoStatement::initializeStorageClassArray (SgGotoStatementStorageArray); ;
3171 0 : assert ( storageClassIndex == sizeOfActualPool );
3172 : }
3173 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGraph ) ;
3174 0 : std::cout << " SgGraph has size " << sizeOfActualPool << std::endl;
3175 0 : SgGraphStorageClass* SgGraphStorageArray = NULL;
3176 0 : if ( 0 < sizeOfActualPool )
3177 : {
3178 0 : SgGraphStorageArray = new SgGraphStorageClass[sizeOfActualPool] ;
3179 0 : unsigned long storageClassIndex = SgGraph::initializeStorageClassArray (SgGraphStorageArray); ;
3180 0 : assert ( storageClassIndex == sizeOfActualPool );
3181 : }
3182 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGraphEdge ) ;
3183 0 : std::cout << " SgGraphEdge has size " << sizeOfActualPool << std::endl;
3184 0 : SgGraphEdgeStorageClass* SgGraphEdgeStorageArray = NULL;
3185 0 : if ( 0 < sizeOfActualPool )
3186 : {
3187 0 : SgGraphEdgeStorageArray = new SgGraphEdgeStorageClass[sizeOfActualPool] ;
3188 0 : unsigned long storageClassIndex = SgGraphEdge::initializeStorageClassArray (SgGraphEdgeStorageArray); ;
3189 0 : assert ( storageClassIndex == sizeOfActualPool );
3190 : }
3191 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGraphEdgeList ) ;
3192 0 : std::cout << " SgGraphEdgeList has size " << sizeOfActualPool << std::endl;
3193 0 : SgGraphEdgeListStorageClass* SgGraphEdgeListStorageArray = NULL;
3194 0 : if ( 0 < sizeOfActualPool )
3195 : {
3196 0 : SgGraphEdgeListStorageArray = new SgGraphEdgeListStorageClass[sizeOfActualPool] ;
3197 0 : unsigned long storageClassIndex = SgGraphEdgeList::initializeStorageClassArray (SgGraphEdgeListStorageArray); ;
3198 0 : assert ( storageClassIndex == sizeOfActualPool );
3199 : }
3200 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGraphNode ) ;
3201 0 : std::cout << " SgGraphNode has size " << sizeOfActualPool << std::endl;
3202 0 : SgGraphNodeStorageClass* SgGraphNodeStorageArray = NULL;
3203 0 : if ( 0 < sizeOfActualPool )
3204 : {
3205 0 : SgGraphNodeStorageArray = new SgGraphNodeStorageClass[sizeOfActualPool] ;
3206 0 : unsigned long storageClassIndex = SgGraphNode::initializeStorageClassArray (SgGraphNodeStorageArray); ;
3207 0 : assert ( storageClassIndex == sizeOfActualPool );
3208 : }
3209 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGraphNodeList ) ;
3210 0 : std::cout << " SgGraphNodeList has size " << sizeOfActualPool << std::endl;
3211 0 : SgGraphNodeListStorageClass* SgGraphNodeListStorageArray = NULL;
3212 0 : if ( 0 < sizeOfActualPool )
3213 : {
3214 0 : SgGraphNodeListStorageArray = new SgGraphNodeListStorageClass[sizeOfActualPool] ;
3215 0 : unsigned long storageClassIndex = SgGraphNodeList::initializeStorageClassArray (SgGraphNodeListStorageArray); ;
3216 0 : assert ( storageClassIndex == sizeOfActualPool );
3217 : }
3218 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGreaterOrEqualOp ) ;
3219 0 : std::cout << " SgGreaterOrEqualOp has size " << sizeOfActualPool << std::endl;
3220 0 : SgGreaterOrEqualOpStorageClass* SgGreaterOrEqualOpStorageArray = NULL;
3221 0 : if ( 0 < sizeOfActualPool )
3222 : {
3223 0 : SgGreaterOrEqualOpStorageArray = new SgGreaterOrEqualOpStorageClass[sizeOfActualPool] ;
3224 0 : unsigned long storageClassIndex = SgGreaterOrEqualOp::initializeStorageClassArray (SgGreaterOrEqualOpStorageArray); ;
3225 0 : assert ( storageClassIndex == sizeOfActualPool );
3226 : }
3227 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgGreaterThanOp ) ;
3228 0 : std::cout << " SgGreaterThanOp has size " << sizeOfActualPool << std::endl;
3229 0 : SgGreaterThanOpStorageClass* SgGreaterThanOpStorageArray = NULL;
3230 0 : if ( 0 < sizeOfActualPool )
3231 : {
3232 0 : SgGreaterThanOpStorageArray = new SgGreaterThanOpStorageClass[sizeOfActualPool] ;
3233 0 : unsigned long storageClassIndex = SgGreaterThanOp::initializeStorageClassArray (SgGreaterThanOpStorageArray); ;
3234 0 : assert ( storageClassIndex == sizeOfActualPool );
3235 : }
3236 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIOItemExpression ) ;
3237 0 : std::cout << " SgIOItemExpression has size " << sizeOfActualPool << std::endl;
3238 0 : SgIOItemExpressionStorageClass* SgIOItemExpressionStorageArray = NULL;
3239 0 : if ( 0 < sizeOfActualPool )
3240 : {
3241 0 : SgIOItemExpressionStorageArray = new SgIOItemExpressionStorageClass[sizeOfActualPool] ;
3242 0 : unsigned long storageClassIndex = SgIOItemExpression::initializeStorageClassArray (SgIOItemExpressionStorageArray); ;
3243 0 : assert ( storageClassIndex == sizeOfActualPool );
3244 : }
3245 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIOStatement ) ;
3246 0 : std::cout << " SgIOStatement has size " << sizeOfActualPool << std::endl;
3247 0 : SgIOStatementStorageClass* SgIOStatementStorageArray = NULL;
3248 0 : if ( 0 < sizeOfActualPool )
3249 : {
3250 0 : SgIOStatementStorageArray = new SgIOStatementStorageClass[sizeOfActualPool] ;
3251 0 : unsigned long storageClassIndex = SgIOStatement::initializeStorageClassArray (SgIOStatementStorageArray); ;
3252 0 : assert ( storageClassIndex == sizeOfActualPool );
3253 : }
3254 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIdentDirectiveStatement ) ;
3255 0 : std::cout << " SgIdentDirectiveStatement has size " << sizeOfActualPool << std::endl;
3256 0 : SgIdentDirectiveStatementStorageClass* SgIdentDirectiveStatementStorageArray = NULL;
3257 0 : if ( 0 < sizeOfActualPool )
3258 : {
3259 0 : SgIdentDirectiveStatementStorageArray = new SgIdentDirectiveStatementStorageClass[sizeOfActualPool] ;
3260 0 : unsigned long storageClassIndex = SgIdentDirectiveStatement::initializeStorageClassArray (SgIdentDirectiveStatementStorageArray); ;
3261 0 : assert ( storageClassIndex == sizeOfActualPool );
3262 : }
3263 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIfDirectiveStatement ) ;
3264 0 : std::cout << " SgIfDirectiveStatement has size " << sizeOfActualPool << std::endl;
3265 0 : SgIfDirectiveStatementStorageClass* SgIfDirectiveStatementStorageArray = NULL;
3266 0 : if ( 0 < sizeOfActualPool )
3267 : {
3268 0 : SgIfDirectiveStatementStorageArray = new SgIfDirectiveStatementStorageClass[sizeOfActualPool] ;
3269 0 : unsigned long storageClassIndex = SgIfDirectiveStatement::initializeStorageClassArray (SgIfDirectiveStatementStorageArray); ;
3270 0 : assert ( storageClassIndex == sizeOfActualPool );
3271 : }
3272 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIfStmt ) ;
3273 0 : std::cout << " SgIfStmt has size " << sizeOfActualPool << std::endl;
3274 0 : SgIfStmtStorageClass* SgIfStmtStorageArray = NULL;
3275 0 : if ( 0 < sizeOfActualPool )
3276 : {
3277 0 : SgIfStmtStorageArray = new SgIfStmtStorageClass[sizeOfActualPool] ;
3278 0 : unsigned long storageClassIndex = SgIfStmt::initializeStorageClassArray (SgIfStmtStorageArray); ;
3279 0 : assert ( storageClassIndex == sizeOfActualPool );
3280 : }
3281 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIfdefDirectiveStatement ) ;
3282 0 : std::cout << " SgIfdefDirectiveStatement has size " << sizeOfActualPool << std::endl;
3283 0 : SgIfdefDirectiveStatementStorageClass* SgIfdefDirectiveStatementStorageArray = NULL;
3284 0 : if ( 0 < sizeOfActualPool )
3285 : {
3286 0 : SgIfdefDirectiveStatementStorageArray = new SgIfdefDirectiveStatementStorageClass[sizeOfActualPool] ;
3287 0 : unsigned long storageClassIndex = SgIfdefDirectiveStatement::initializeStorageClassArray (SgIfdefDirectiveStatementStorageArray); ;
3288 0 : assert ( storageClassIndex == sizeOfActualPool );
3289 : }
3290 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIfndefDirectiveStatement ) ;
3291 0 : std::cout << " SgIfndefDirectiveStatement has size " << sizeOfActualPool << std::endl;
3292 0 : SgIfndefDirectiveStatementStorageClass* SgIfndefDirectiveStatementStorageArray = NULL;
3293 0 : if ( 0 < sizeOfActualPool )
3294 : {
3295 0 : SgIfndefDirectiveStatementStorageArray = new SgIfndefDirectiveStatementStorageClass[sizeOfActualPool] ;
3296 0 : unsigned long storageClassIndex = SgIfndefDirectiveStatement::initializeStorageClassArray (SgIfndefDirectiveStatementStorageArray); ;
3297 0 : assert ( storageClassIndex == sizeOfActualPool );
3298 : }
3299 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgImageControlStatement ) ;
3300 0 : std::cout << " SgImageControlStatement has size " << sizeOfActualPool << std::endl;
3301 0 : SgImageControlStatementStorageClass* SgImageControlStatementStorageArray = NULL;
3302 0 : if ( 0 < sizeOfActualPool )
3303 : {
3304 0 : SgImageControlStatementStorageArray = new SgImageControlStatementStorageClass[sizeOfActualPool] ;
3305 0 : unsigned long storageClassIndex = SgImageControlStatement::initializeStorageClassArray (SgImageControlStatementStorageArray); ;
3306 0 : assert ( storageClassIndex == sizeOfActualPool );
3307 : }
3308 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgImagPartOp ) ;
3309 0 : std::cout << " SgImagPartOp has size " << sizeOfActualPool << std::endl;
3310 0 : SgImagPartOpStorageClass* SgImagPartOpStorageArray = NULL;
3311 0 : if ( 0 < sizeOfActualPool )
3312 : {
3313 0 : SgImagPartOpStorageArray = new SgImagPartOpStorageClass[sizeOfActualPool] ;
3314 0 : unsigned long storageClassIndex = SgImagPartOp::initializeStorageClassArray (SgImagPartOpStorageArray); ;
3315 0 : assert ( storageClassIndex == sizeOfActualPool );
3316 : }
3317 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgImplicitStatement ) ;
3318 0 : std::cout << " SgImplicitStatement has size " << sizeOfActualPool << std::endl;
3319 0 : SgImplicitStatementStorageClass* SgImplicitStatementStorageArray = NULL;
3320 0 : if ( 0 < sizeOfActualPool )
3321 : {
3322 0 : SgImplicitStatementStorageArray = new SgImplicitStatementStorageClass[sizeOfActualPool] ;
3323 0 : unsigned long storageClassIndex = SgImplicitStatement::initializeStorageClassArray (SgImplicitStatementStorageArray); ;
3324 0 : assert ( storageClassIndex == sizeOfActualPool );
3325 : }
3326 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgImpliedDo ) ;
3327 0 : std::cout << " SgImpliedDo has size " << sizeOfActualPool << std::endl;
3328 0 : SgImpliedDoStorageClass* SgImpliedDoStorageArray = NULL;
3329 0 : if ( 0 < sizeOfActualPool )
3330 : {
3331 0 : SgImpliedDoStorageArray = new SgImpliedDoStorageClass[sizeOfActualPool] ;
3332 0 : unsigned long storageClassIndex = SgImpliedDo::initializeStorageClassArray (SgImpliedDoStorageArray); ;
3333 0 : assert ( storageClassIndex == sizeOfActualPool );
3334 : }
3335 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgImportStatement ) ;
3336 0 : std::cout << " SgImportStatement has size " << sizeOfActualPool << std::endl;
3337 0 : SgImportStatementStorageClass* SgImportStatementStorageArray = NULL;
3338 0 : if ( 0 < sizeOfActualPool )
3339 : {
3340 0 : SgImportStatementStorageArray = new SgImportStatementStorageClass[sizeOfActualPool] ;
3341 0 : unsigned long storageClassIndex = SgImportStatement::initializeStorageClassArray (SgImportStatementStorageArray); ;
3342 0 : assert ( storageClassIndex == sizeOfActualPool );
3343 : }
3344 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIncidenceDirectedGraph ) ;
3345 0 : std::cout << " SgIncidenceDirectedGraph has size " << sizeOfActualPool << std::endl;
3346 0 : SgIncidenceDirectedGraphStorageClass* SgIncidenceDirectedGraphStorageArray = NULL;
3347 0 : if ( 0 < sizeOfActualPool )
3348 : {
3349 0 : SgIncidenceDirectedGraphStorageArray = new SgIncidenceDirectedGraphStorageClass[sizeOfActualPool] ;
3350 0 : unsigned long storageClassIndex = SgIncidenceDirectedGraph::initializeStorageClassArray (SgIncidenceDirectedGraphStorageArray); ;
3351 0 : assert ( storageClassIndex == sizeOfActualPool );
3352 : }
3353 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIncidenceUndirectedGraph ) ;
3354 0 : std::cout << " SgIncidenceUndirectedGraph has size " << sizeOfActualPool << std::endl;
3355 0 : SgIncidenceUndirectedGraphStorageClass* SgIncidenceUndirectedGraphStorageArray = NULL;
3356 0 : if ( 0 < sizeOfActualPool )
3357 : {
3358 0 : SgIncidenceUndirectedGraphStorageArray = new SgIncidenceUndirectedGraphStorageClass[sizeOfActualPool] ;
3359 0 : unsigned long storageClassIndex = SgIncidenceUndirectedGraph::initializeStorageClassArray (SgIncidenceUndirectedGraphStorageArray); ;
3360 0 : assert ( storageClassIndex == sizeOfActualPool );
3361 : }
3362 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIncludeDirectiveStatement ) ;
3363 0 : std::cout << " SgIncludeDirectiveStatement has size " << sizeOfActualPool << std::endl;
3364 0 : SgIncludeDirectiveStatementStorageClass* SgIncludeDirectiveStatementStorageArray = NULL;
3365 0 : if ( 0 < sizeOfActualPool )
3366 : {
3367 0 : SgIncludeDirectiveStatementStorageArray = new SgIncludeDirectiveStatementStorageClass[sizeOfActualPool] ;
3368 0 : unsigned long storageClassIndex = SgIncludeDirectiveStatement::initializeStorageClassArray (SgIncludeDirectiveStatementStorageArray); ;
3369 0 : assert ( storageClassIndex == sizeOfActualPool );
3370 : }
3371 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIncludeFile ) ;
3372 0 : std::cout << " SgIncludeFile has size " << sizeOfActualPool << std::endl;
3373 0 : SgIncludeFileStorageClass* SgIncludeFileStorageArray = NULL;
3374 0 : if ( 0 < sizeOfActualPool )
3375 : {
3376 0 : SgIncludeFileStorageArray = new SgIncludeFileStorageClass[sizeOfActualPool] ;
3377 0 : unsigned long storageClassIndex = SgIncludeFile::initializeStorageClassArray (SgIncludeFileStorageArray); ;
3378 0 : assert ( storageClassIndex == sizeOfActualPool );
3379 : }
3380 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIncludeNextDirectiveStatement ) ;
3381 0 : std::cout << " SgIncludeNextDirectiveStatement has size " << sizeOfActualPool << std::endl;
3382 0 : SgIncludeNextDirectiveStatementStorageClass* SgIncludeNextDirectiveStatementStorageArray = NULL;
3383 0 : if ( 0 < sizeOfActualPool )
3384 : {
3385 0 : SgIncludeNextDirectiveStatementStorageArray = new SgIncludeNextDirectiveStatementStorageClass[sizeOfActualPool] ;
3386 0 : unsigned long storageClassIndex = SgIncludeNextDirectiveStatement::initializeStorageClassArray (SgIncludeNextDirectiveStatementStorageArray); ;
3387 0 : assert ( storageClassIndex == sizeOfActualPool );
3388 : }
3389 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInitializedName ) ;
3390 0 : std::cout << " SgInitializedName has size " << sizeOfActualPool << std::endl;
3391 0 : SgInitializedNameStorageClass* SgInitializedNameStorageArray = NULL;
3392 0 : if ( 0 < sizeOfActualPool )
3393 : {
3394 0 : SgInitializedNameStorageArray = new SgInitializedNameStorageClass[sizeOfActualPool] ;
3395 0 : unsigned long storageClassIndex = SgInitializedName::initializeStorageClassArray (SgInitializedNameStorageArray); ;
3396 0 : assert ( storageClassIndex == sizeOfActualPool );
3397 : }
3398 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInitializer ) ;
3399 0 : std::cout << " SgInitializer has size " << sizeOfActualPool << std::endl;
3400 0 : SgInitializerStorageClass* SgInitializerStorageArray = NULL;
3401 0 : if ( 0 < sizeOfActualPool )
3402 : {
3403 0 : SgInitializerStorageArray = new SgInitializerStorageClass[sizeOfActualPool] ;
3404 0 : unsigned long storageClassIndex = SgInitializer::initializeStorageClassArray (SgInitializerStorageArray); ;
3405 0 : assert ( storageClassIndex == sizeOfActualPool );
3406 : }
3407 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInquireStatement ) ;
3408 0 : std::cout << " SgInquireStatement has size " << sizeOfActualPool << std::endl;
3409 0 : SgInquireStatementStorageClass* SgInquireStatementStorageArray = NULL;
3410 0 : if ( 0 < sizeOfActualPool )
3411 : {
3412 0 : SgInquireStatementStorageArray = new SgInquireStatementStorageClass[sizeOfActualPool] ;
3413 0 : unsigned long storageClassIndex = SgInquireStatement::initializeStorageClassArray (SgInquireStatementStorageArray); ;
3414 0 : assert ( storageClassIndex == sizeOfActualPool );
3415 : }
3416 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIntKeyedBidirectionalGraph ) ;
3417 0 : std::cout << " SgIntKeyedBidirectionalGraph has size " << sizeOfActualPool << std::endl;
3418 0 : SgIntKeyedBidirectionalGraphStorageClass* SgIntKeyedBidirectionalGraphStorageArray = NULL;
3419 0 : if ( 0 < sizeOfActualPool )
3420 : {
3421 0 : SgIntKeyedBidirectionalGraphStorageArray = new SgIntKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
3422 0 : unsigned long storageClassIndex = SgIntKeyedBidirectionalGraph::initializeStorageClassArray (SgIntKeyedBidirectionalGraphStorageArray); ;
3423 0 : assert ( storageClassIndex == sizeOfActualPool );
3424 : }
3425 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIntVal ) ;
3426 0 : std::cout << " SgIntVal has size " << sizeOfActualPool << std::endl;
3427 0 : SgIntValStorageClass* SgIntValStorageArray = NULL;
3428 0 : if ( 0 < sizeOfActualPool )
3429 : {
3430 0 : SgIntValStorageArray = new SgIntValStorageClass[sizeOfActualPool] ;
3431 0 : unsigned long storageClassIndex = SgIntVal::initializeStorageClassArray (SgIntValStorageArray); ;
3432 0 : assert ( storageClassIndex == sizeOfActualPool );
3433 : }
3434 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIntegerDivideOp ) ;
3435 0 : std::cout << " SgIntegerDivideOp has size " << sizeOfActualPool << std::endl;
3436 0 : SgIntegerDivideOpStorageClass* SgIntegerDivideOpStorageArray = NULL;
3437 0 : if ( 0 < sizeOfActualPool )
3438 : {
3439 0 : SgIntegerDivideOpStorageArray = new SgIntegerDivideOpStorageClass[sizeOfActualPool] ;
3440 0 : unsigned long storageClassIndex = SgIntegerDivideOp::initializeStorageClassArray (SgIntegerDivideOpStorageArray); ;
3441 0 : assert ( storageClassIndex == sizeOfActualPool );
3442 : }
3443 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIntegerDivideAssignOp ) ;
3444 0 : std::cout << " SgIntegerDivideAssignOp has size " << sizeOfActualPool << std::endl;
3445 0 : SgIntegerDivideAssignOpStorageClass* SgIntegerDivideAssignOpStorageArray = NULL;
3446 0 : if ( 0 < sizeOfActualPool )
3447 : {
3448 0 : SgIntegerDivideAssignOpStorageArray = new SgIntegerDivideAssignOpStorageClass[sizeOfActualPool] ;
3449 0 : unsigned long storageClassIndex = SgIntegerDivideAssignOp::initializeStorageClassArray (SgIntegerDivideAssignOpStorageArray); ;
3450 0 : assert ( storageClassIndex == sizeOfActualPool );
3451 : }
3452 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInterfaceBody ) ;
3453 0 : std::cout << " SgInterfaceBody has size " << sizeOfActualPool << std::endl;
3454 0 : SgInterfaceBodyStorageClass* SgInterfaceBodyStorageArray = NULL;
3455 0 : if ( 0 < sizeOfActualPool )
3456 : {
3457 0 : SgInterfaceBodyStorageArray = new SgInterfaceBodyStorageClass[sizeOfActualPool] ;
3458 0 : unsigned long storageClassIndex = SgInterfaceBody::initializeStorageClassArray (SgInterfaceBodyStorageArray); ;
3459 0 : assert ( storageClassIndex == sizeOfActualPool );
3460 : }
3461 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgHeaderFileBody ) ;
3462 0 : std::cout << " SgHeaderFileBody has size " << sizeOfActualPool << std::endl;
3463 0 : SgHeaderFileBodyStorageClass* SgHeaderFileBodyStorageArray = NULL;
3464 0 : if ( 0 < sizeOfActualPool )
3465 : {
3466 0 : SgHeaderFileBodyStorageArray = new SgHeaderFileBodyStorageClass[sizeOfActualPool] ;
3467 0 : unsigned long storageClassIndex = SgHeaderFileBody::initializeStorageClassArray (SgHeaderFileBodyStorageArray); ;
3468 0 : assert ( storageClassIndex == sizeOfActualPool );
3469 : }
3470 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgHeaderFileReport ) ;
3471 0 : std::cout << " SgHeaderFileReport has size " << sizeOfActualPool << std::endl;
3472 0 : SgHeaderFileReportStorageClass* SgHeaderFileReportStorageArray = NULL;
3473 0 : if ( 0 < sizeOfActualPool )
3474 : {
3475 0 : SgHeaderFileReportStorageArray = new SgHeaderFileReportStorageClass[sizeOfActualPool] ;
3476 0 : unsigned long storageClassIndex = SgHeaderFileReport::initializeStorageClassArray (SgHeaderFileReportStorageArray); ;
3477 0 : assert ( storageClassIndex == sizeOfActualPool );
3478 : }
3479 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInterfaceStatement ) ;
3480 0 : std::cout << " SgInterfaceStatement has size " << sizeOfActualPool << std::endl;
3481 0 : SgInterfaceStatementStorageClass* SgInterfaceStatementStorageArray = NULL;
3482 0 : if ( 0 < sizeOfActualPool )
3483 : {
3484 0 : SgInterfaceStatementStorageArray = new SgInterfaceStatementStorageClass[sizeOfActualPool] ;
3485 0 : unsigned long storageClassIndex = SgInterfaceStatement::initializeStorageClassArray (SgInterfaceStatementStorageArray); ;
3486 0 : assert ( storageClassIndex == sizeOfActualPool );
3487 : }
3488 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgInterfaceSymbol ) ;
3489 0 : std::cout << " SgInterfaceSymbol has size " << sizeOfActualPool << std::endl;
3490 0 : SgInterfaceSymbolStorageClass* SgInterfaceSymbolStorageArray = NULL;
3491 0 : if ( 0 < sizeOfActualPool )
3492 : {
3493 0 : SgInterfaceSymbolStorageArray = new SgInterfaceSymbolStorageClass[sizeOfActualPool] ;
3494 0 : unsigned long storageClassIndex = SgInterfaceSymbol::initializeStorageClassArray (SgInterfaceSymbolStorageArray); ;
3495 0 : assert ( storageClassIndex == sizeOfActualPool );
3496 : }
3497 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIntrinsicSymbol ) ;
3498 0 : std::cout << " SgIntrinsicSymbol has size " << sizeOfActualPool << std::endl;
3499 0 : SgIntrinsicSymbolStorageClass* SgIntrinsicSymbolStorageArray = NULL;
3500 0 : if ( 0 < sizeOfActualPool )
3501 : {
3502 0 : SgIntrinsicSymbolStorageArray = new SgIntrinsicSymbolStorageClass[sizeOfActualPool] ;
3503 0 : unsigned long storageClassIndex = SgIntrinsicSymbol::initializeStorageClassArray (SgIntrinsicSymbolStorageArray); ;
3504 0 : assert ( storageClassIndex == sizeOfActualPool );
3505 : }
3506 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIsOp ) ;
3507 0 : std::cout << " SgIsOp has size " << sizeOfActualPool << std::endl;
3508 0 : SgIsOpStorageClass* SgIsOpStorageArray = NULL;
3509 0 : if ( 0 < sizeOfActualPool )
3510 : {
3511 0 : SgIsOpStorageArray = new SgIsOpStorageClass[sizeOfActualPool] ;
3512 0 : unsigned long storageClassIndex = SgIsOp::initializeStorageClassArray (SgIsOpStorageArray); ;
3513 0 : assert ( storageClassIndex == sizeOfActualPool );
3514 : }
3515 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIsNotOp ) ;
3516 0 : std::cout << " SgIsNotOp has size " << sizeOfActualPool << std::endl;
3517 0 : SgIsNotOpStorageClass* SgIsNotOpStorageArray = NULL;
3518 0 : if ( 0 < sizeOfActualPool )
3519 : {
3520 0 : SgIsNotOpStorageArray = new SgIsNotOpStorageClass[sizeOfActualPool] ;
3521 0 : unsigned long storageClassIndex = SgIsNotOp::initializeStorageClassArray (SgIsNotOpStorageArray); ;
3522 0 : assert ( storageClassIndex == sizeOfActualPool );
3523 : }
3524 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgIorAssignOp ) ;
3525 0 : std::cout << " SgIorAssignOp has size " << sizeOfActualPool << std::endl;
3526 0 : SgIorAssignOpStorageClass* SgIorAssignOpStorageArray = NULL;
3527 0 : if ( 0 < sizeOfActualPool )
3528 : {
3529 0 : SgIorAssignOpStorageArray = new SgIorAssignOpStorageClass[sizeOfActualPool] ;
3530 0 : unsigned long storageClassIndex = SgIorAssignOp::initializeStorageClassArray (SgIorAssignOpStorageArray); ;
3531 0 : assert ( storageClassIndex == sizeOfActualPool );
3532 : }
3533 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgKeyDatumPair ) ;
3534 0 : std::cout << " SgKeyDatumPair has size " << sizeOfActualPool << std::endl;
3535 0 : SgKeyDatumPairStorageClass* SgKeyDatumPairStorageArray = NULL;
3536 0 : if ( 0 < sizeOfActualPool )
3537 : {
3538 0 : SgKeyDatumPairStorageArray = new SgKeyDatumPairStorageClass[sizeOfActualPool] ;
3539 0 : unsigned long storageClassIndex = SgKeyDatumPair::initializeStorageClassArray (SgKeyDatumPairStorageArray); ;
3540 0 : assert ( storageClassIndex == sizeOfActualPool );
3541 : }
3542 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCudaKernelExecConfig ) ;
3543 0 : std::cout << " SgCudaKernelExecConfig has size " << sizeOfActualPool << std::endl;
3544 0 : SgCudaKernelExecConfigStorageClass* SgCudaKernelExecConfigStorageArray = NULL;
3545 0 : if ( 0 < sizeOfActualPool )
3546 : {
3547 0 : SgCudaKernelExecConfigStorageArray = new SgCudaKernelExecConfigStorageClass[sizeOfActualPool] ;
3548 0 : unsigned long storageClassIndex = SgCudaKernelExecConfig::initializeStorageClassArray (SgCudaKernelExecConfigStorageArray); ;
3549 0 : assert ( storageClassIndex == sizeOfActualPool );
3550 : }
3551 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCudaKernelCallExp ) ;
3552 0 : std::cout << " SgCudaKernelCallExp has size " << sizeOfActualPool << std::endl;
3553 0 : SgCudaKernelCallExpStorageClass* SgCudaKernelCallExpStorageArray = NULL;
3554 0 : if ( 0 < sizeOfActualPool )
3555 : {
3556 0 : SgCudaKernelCallExpStorageArray = new SgCudaKernelCallExpStorageClass[sizeOfActualPool] ;
3557 0 : unsigned long storageClassIndex = SgCudaKernelCallExp::initializeStorageClassArray (SgCudaKernelCallExpStorageArray); ;
3558 0 : assert ( storageClassIndex == sizeOfActualPool );
3559 : }
3560 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLabelRefExp ) ;
3561 0 : std::cout << " SgLabelRefExp has size " << sizeOfActualPool << std::endl;
3562 0 : SgLabelRefExpStorageClass* SgLabelRefExpStorageArray = NULL;
3563 0 : if ( 0 < sizeOfActualPool )
3564 : {
3565 0 : SgLabelRefExpStorageArray = new SgLabelRefExpStorageClass[sizeOfActualPool] ;
3566 0 : unsigned long storageClassIndex = SgLabelRefExp::initializeStorageClassArray (SgLabelRefExpStorageArray); ;
3567 0 : assert ( storageClassIndex == sizeOfActualPool );
3568 : }
3569 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLabelStatement ) ;
3570 0 : std::cout << " SgLabelStatement has size " << sizeOfActualPool << std::endl;
3571 0 : SgLabelStatementStorageClass* SgLabelStatementStorageArray = NULL;
3572 0 : if ( 0 < sizeOfActualPool )
3573 : {
3574 0 : SgLabelStatementStorageArray = new SgLabelStatementStorageClass[sizeOfActualPool] ;
3575 0 : unsigned long storageClassIndex = SgLabelStatement::initializeStorageClassArray (SgLabelStatementStorageArray); ;
3576 0 : assert ( storageClassIndex == sizeOfActualPool );
3577 : }
3578 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLabelSymbol ) ;
3579 0 : std::cout << " SgLabelSymbol has size " << sizeOfActualPool << std::endl;
3580 0 : SgLabelSymbolStorageClass* SgLabelSymbolStorageArray = NULL;
3581 0 : if ( 0 < sizeOfActualPool )
3582 : {
3583 0 : SgLabelSymbolStorageArray = new SgLabelSymbolStorageClass[sizeOfActualPool] ;
3584 0 : unsigned long storageClassIndex = SgLabelSymbol::initializeStorageClassArray (SgLabelSymbolStorageArray); ;
3585 0 : assert ( storageClassIndex == sizeOfActualPool );
3586 : }
3587 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLambdaCapture ) ;
3588 0 : std::cout << " SgLambdaCapture has size " << sizeOfActualPool << std::endl;
3589 0 : SgLambdaCaptureStorageClass* SgLambdaCaptureStorageArray = NULL;
3590 0 : if ( 0 < sizeOfActualPool )
3591 : {
3592 0 : SgLambdaCaptureStorageArray = new SgLambdaCaptureStorageClass[sizeOfActualPool] ;
3593 0 : unsigned long storageClassIndex = SgLambdaCapture::initializeStorageClassArray (SgLambdaCaptureStorageArray); ;
3594 0 : assert ( storageClassIndex == sizeOfActualPool );
3595 : }
3596 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLambdaCaptureList ) ;
3597 0 : std::cout << " SgLambdaCaptureList has size " << sizeOfActualPool << std::endl;
3598 0 : SgLambdaCaptureListStorageClass* SgLambdaCaptureListStorageArray = NULL;
3599 0 : if ( 0 < sizeOfActualPool )
3600 : {
3601 0 : SgLambdaCaptureListStorageArray = new SgLambdaCaptureListStorageClass[sizeOfActualPool] ;
3602 0 : unsigned long storageClassIndex = SgLambdaCaptureList::initializeStorageClassArray (SgLambdaCaptureListStorageArray); ;
3603 0 : assert ( storageClassIndex == sizeOfActualPool );
3604 : }
3605 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLambdaExp ) ;
3606 0 : std::cout << " SgLambdaExp has size " << sizeOfActualPool << std::endl;
3607 0 : SgLambdaExpStorageClass* SgLambdaExpStorageArray = NULL;
3608 0 : if ( 0 < sizeOfActualPool )
3609 : {
3610 0 : SgLambdaExpStorageArray = new SgLambdaExpStorageClass[sizeOfActualPool] ;
3611 0 : unsigned long storageClassIndex = SgLambdaExp::initializeStorageClassArray (SgLambdaExpStorageArray); ;
3612 0 : assert ( storageClassIndex == sizeOfActualPool );
3613 : }
3614 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLambdaRefExp ) ;
3615 0 : std::cout << " SgLambdaRefExp has size " << sizeOfActualPool << std::endl;
3616 0 : SgLambdaRefExpStorageClass* SgLambdaRefExpStorageArray = NULL;
3617 0 : if ( 0 < sizeOfActualPool )
3618 : {
3619 0 : SgLambdaRefExpStorageArray = new SgLambdaRefExpStorageClass[sizeOfActualPool] ;
3620 0 : unsigned long storageClassIndex = SgLambdaRefExp::initializeStorageClassArray (SgLambdaRefExpStorageArray); ;
3621 0 : assert ( storageClassIndex == sizeOfActualPool );
3622 : }
3623 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLeftDivideOp ) ;
3624 0 : std::cout << " SgLeftDivideOp has size " << sizeOfActualPool << std::endl;
3625 0 : SgLeftDivideOpStorageClass* SgLeftDivideOpStorageArray = NULL;
3626 0 : if ( 0 < sizeOfActualPool )
3627 : {
3628 0 : SgLeftDivideOpStorageArray = new SgLeftDivideOpStorageClass[sizeOfActualPool] ;
3629 0 : unsigned long storageClassIndex = SgLeftDivideOp::initializeStorageClassArray (SgLeftDivideOpStorageArray); ;
3630 0 : assert ( storageClassIndex == sizeOfActualPool );
3631 : }
3632 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLessOrEqualOp ) ;
3633 0 : std::cout << " SgLessOrEqualOp has size " << sizeOfActualPool << std::endl;
3634 0 : SgLessOrEqualOpStorageClass* SgLessOrEqualOpStorageArray = NULL;
3635 0 : if ( 0 < sizeOfActualPool )
3636 : {
3637 0 : SgLessOrEqualOpStorageArray = new SgLessOrEqualOpStorageClass[sizeOfActualPool] ;
3638 0 : unsigned long storageClassIndex = SgLessOrEqualOp::initializeStorageClassArray (SgLessOrEqualOpStorageArray); ;
3639 0 : assert ( storageClassIndex == sizeOfActualPool );
3640 : }
3641 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLessThanOp ) ;
3642 0 : std::cout << " SgLessThanOp has size " << sizeOfActualPool << std::endl;
3643 0 : SgLessThanOpStorageClass* SgLessThanOpStorageArray = NULL;
3644 0 : if ( 0 < sizeOfActualPool )
3645 : {
3646 0 : SgLessThanOpStorageArray = new SgLessThanOpStorageClass[sizeOfActualPool] ;
3647 0 : unsigned long storageClassIndex = SgLessThanOp::initializeStorageClassArray (SgLessThanOpStorageArray); ;
3648 0 : assert ( storageClassIndex == sizeOfActualPool );
3649 : }
3650 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLineDirectiveStatement ) ;
3651 0 : std::cout << " SgLineDirectiveStatement has size " << sizeOfActualPool << std::endl;
3652 0 : SgLineDirectiveStatementStorageClass* SgLineDirectiveStatementStorageArray = NULL;
3653 0 : if ( 0 < sizeOfActualPool )
3654 : {
3655 0 : SgLineDirectiveStatementStorageArray = new SgLineDirectiveStatementStorageClass[sizeOfActualPool] ;
3656 0 : unsigned long storageClassIndex = SgLineDirectiveStatement::initializeStorageClassArray (SgLineDirectiveStatementStorageArray); ;
3657 0 : assert ( storageClassIndex == sizeOfActualPool );
3658 : }
3659 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLinemarkerDirectiveStatement ) ;
3660 0 : std::cout << " SgLinemarkerDirectiveStatement has size " << sizeOfActualPool << std::endl;
3661 0 : SgLinemarkerDirectiveStatementStorageClass* SgLinemarkerDirectiveStatementStorageArray = NULL;
3662 0 : if ( 0 < sizeOfActualPool )
3663 : {
3664 0 : SgLinemarkerDirectiveStatementStorageArray = new SgLinemarkerDirectiveStatementStorageClass[sizeOfActualPool] ;
3665 0 : unsigned long storageClassIndex = SgLinemarkerDirectiveStatement::initializeStorageClassArray (SgLinemarkerDirectiveStatementStorageArray); ;
3666 0 : assert ( storageClassIndex == sizeOfActualPool );
3667 : }
3668 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLinkageModifier ) ;
3669 0 : std::cout << " SgLinkageModifier has size " << sizeOfActualPool << std::endl;
3670 0 : SgLinkageModifierStorageClass* SgLinkageModifierStorageArray = NULL;
3671 0 : if ( 0 < sizeOfActualPool )
3672 : {
3673 0 : SgLinkageModifierStorageArray = new SgLinkageModifierStorageClass[sizeOfActualPool] ;
3674 0 : unsigned long storageClassIndex = SgLinkageModifier::initializeStorageClassArray (SgLinkageModifierStorageArray); ;
3675 0 : assert ( storageClassIndex == sizeOfActualPool );
3676 : }
3677 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgListComprehension ) ;
3678 0 : std::cout << " SgListComprehension has size " << sizeOfActualPool << std::endl;
3679 0 : SgListComprehensionStorageClass* SgListComprehensionStorageArray = NULL;
3680 0 : if ( 0 < sizeOfActualPool )
3681 : {
3682 0 : SgListComprehensionStorageArray = new SgListComprehensionStorageClass[sizeOfActualPool] ;
3683 0 : unsigned long storageClassIndex = SgListComprehension::initializeStorageClassArray (SgListComprehensionStorageArray); ;
3684 0 : assert ( storageClassIndex == sizeOfActualPool );
3685 : }
3686 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgListExp ) ;
3687 0 : std::cout << " SgListExp has size " << sizeOfActualPool << std::endl;
3688 0 : SgListExpStorageClass* SgListExpStorageArray = NULL;
3689 0 : if ( 0 < sizeOfActualPool )
3690 : {
3691 0 : SgListExpStorageArray = new SgListExpStorageClass[sizeOfActualPool] ;
3692 0 : unsigned long storageClassIndex = SgListExp::initializeStorageClassArray (SgListExpStorageArray); ;
3693 0 : assert ( storageClassIndex == sizeOfActualPool );
3694 : }
3695 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLocatedNode ) ;
3696 0 : std::cout << " SgLocatedNode has size " << sizeOfActualPool << std::endl;
3697 0 : SgLocatedNodeStorageClass* SgLocatedNodeStorageArray = NULL;
3698 0 : if ( 0 < sizeOfActualPool )
3699 : {
3700 0 : SgLocatedNodeStorageArray = new SgLocatedNodeStorageClass[sizeOfActualPool] ;
3701 0 : unsigned long storageClassIndex = SgLocatedNode::initializeStorageClassArray (SgLocatedNodeStorageArray); ;
3702 0 : assert ( storageClassIndex == sizeOfActualPool );
3703 : }
3704 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLocatedNodeSupport ) ;
3705 0 : std::cout << " SgLocatedNodeSupport has size " << sizeOfActualPool << std::endl;
3706 0 : SgLocatedNodeSupportStorageClass* SgLocatedNodeSupportStorageArray = NULL;
3707 0 : if ( 0 < sizeOfActualPool )
3708 : {
3709 0 : SgLocatedNodeSupportStorageArray = new SgLocatedNodeSupportStorageClass[sizeOfActualPool] ;
3710 0 : unsigned long storageClassIndex = SgLocatedNodeSupport::initializeStorageClassArray (SgLocatedNodeSupportStorageArray); ;
3711 0 : assert ( storageClassIndex == sizeOfActualPool );
3712 : }
3713 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLongDoubleVal ) ;
3714 0 : std::cout << " SgLongDoubleVal has size " << sizeOfActualPool << std::endl;
3715 0 : SgLongDoubleValStorageClass* SgLongDoubleValStorageArray = NULL;
3716 0 : if ( 0 < sizeOfActualPool )
3717 : {
3718 0 : SgLongDoubleValStorageArray = new SgLongDoubleValStorageClass[sizeOfActualPool] ;
3719 0 : unsigned long storageClassIndex = SgLongDoubleVal::initializeStorageClassArray (SgLongDoubleValStorageArray); ;
3720 0 : assert ( storageClassIndex == sizeOfActualPool );
3721 : }
3722 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLongIntVal ) ;
3723 0 : std::cout << " SgLongIntVal has size " << sizeOfActualPool << std::endl;
3724 0 : SgLongIntValStorageClass* SgLongIntValStorageArray = NULL;
3725 0 : if ( 0 < sizeOfActualPool )
3726 : {
3727 0 : SgLongIntValStorageArray = new SgLongIntValStorageClass[sizeOfActualPool] ;
3728 0 : unsigned long storageClassIndex = SgLongIntVal::initializeStorageClassArray (SgLongIntValStorageArray); ;
3729 0 : assert ( storageClassIndex == sizeOfActualPool );
3730 : }
3731 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLongLongIntVal ) ;
3732 0 : std::cout << " SgLongLongIntVal has size " << sizeOfActualPool << std::endl;
3733 0 : SgLongLongIntValStorageClass* SgLongLongIntValStorageArray = NULL;
3734 0 : if ( 0 < sizeOfActualPool )
3735 : {
3736 0 : SgLongLongIntValStorageArray = new SgLongLongIntValStorageClass[sizeOfActualPool] ;
3737 0 : unsigned long storageClassIndex = SgLongLongIntVal::initializeStorageClassArray (SgLongLongIntValStorageArray); ;
3738 0 : assert ( storageClassIndex == sizeOfActualPool );
3739 : }
3740 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLshiftAssignOp ) ;
3741 0 : std::cout << " SgLshiftAssignOp has size " << sizeOfActualPool << std::endl;
3742 0 : SgLshiftAssignOpStorageClass* SgLshiftAssignOpStorageArray = NULL;
3743 0 : if ( 0 < sizeOfActualPool )
3744 : {
3745 0 : SgLshiftAssignOpStorageArray = new SgLshiftAssignOpStorageClass[sizeOfActualPool] ;
3746 0 : unsigned long storageClassIndex = SgLshiftAssignOp::initializeStorageClassArray (SgLshiftAssignOpStorageArray); ;
3747 0 : assert ( storageClassIndex == sizeOfActualPool );
3748 : }
3749 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLshiftOp ) ;
3750 0 : std::cout << " SgLshiftOp has size " << sizeOfActualPool << std::endl;
3751 0 : SgLshiftOpStorageClass* SgLshiftOpStorageArray = NULL;
3752 0 : if ( 0 < sizeOfActualPool )
3753 : {
3754 0 : SgLshiftOpStorageArray = new SgLshiftOpStorageClass[sizeOfActualPool] ;
3755 0 : unsigned long storageClassIndex = SgLshiftOp::initializeStorageClassArray (SgLshiftOpStorageArray); ;
3756 0 : assert ( storageClassIndex == sizeOfActualPool );
3757 : }
3758 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMagicColonExp ) ;
3759 0 : std::cout << " SgMagicColonExp has size " << sizeOfActualPool << std::endl;
3760 0 : SgMagicColonExpStorageClass* SgMagicColonExpStorageArray = NULL;
3761 0 : if ( 0 < sizeOfActualPool )
3762 : {
3763 0 : SgMagicColonExpStorageArray = new SgMagicColonExpStorageClass[sizeOfActualPool] ;
3764 0 : unsigned long storageClassIndex = SgMagicColonExp::initializeStorageClassArray (SgMagicColonExpStorageArray); ;
3765 0 : assert ( storageClassIndex == sizeOfActualPool );
3766 : }
3767 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMatrixExp ) ;
3768 0 : std::cout << " SgMatrixExp has size " << sizeOfActualPool << std::endl;
3769 0 : SgMatrixExpStorageClass* SgMatrixExpStorageArray = NULL;
3770 0 : if ( 0 < sizeOfActualPool )
3771 : {
3772 0 : SgMatrixExpStorageArray = new SgMatrixExpStorageClass[sizeOfActualPool] ;
3773 0 : unsigned long storageClassIndex = SgMatrixExp::initializeStorageClassArray (SgMatrixExpStorageArray); ;
3774 0 : assert ( storageClassIndex == sizeOfActualPool );
3775 : }
3776 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMatrixTransposeOp ) ;
3777 0 : std::cout << " SgMatrixTransposeOp has size " << sizeOfActualPool << std::endl;
3778 0 : SgMatrixTransposeOpStorageClass* SgMatrixTransposeOpStorageArray = NULL;
3779 0 : if ( 0 < sizeOfActualPool )
3780 : {
3781 0 : SgMatrixTransposeOpStorageArray = new SgMatrixTransposeOpStorageClass[sizeOfActualPool] ;
3782 0 : unsigned long storageClassIndex = SgMatrixTransposeOp::initializeStorageClassArray (SgMatrixTransposeOpStorageArray); ;
3783 0 : assert ( storageClassIndex == sizeOfActualPool );
3784 : }
3785 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMemberFunctionDeclaration ) ;
3786 0 : std::cout << " SgMemberFunctionDeclaration has size " << sizeOfActualPool << std::endl;
3787 0 : SgMemberFunctionDeclarationStorageClass* SgMemberFunctionDeclarationStorageArray = NULL;
3788 0 : if ( 0 < sizeOfActualPool )
3789 : {
3790 0 : SgMemberFunctionDeclarationStorageArray = new SgMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
3791 0 : unsigned long storageClassIndex = SgMemberFunctionDeclaration::initializeStorageClassArray (SgMemberFunctionDeclarationStorageArray); ;
3792 0 : assert ( storageClassIndex == sizeOfActualPool );
3793 : }
3794 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMemberFunctionRefExp ) ;
3795 0 : std::cout << " SgMemberFunctionRefExp has size " << sizeOfActualPool << std::endl;
3796 0 : SgMemberFunctionRefExpStorageClass* SgMemberFunctionRefExpStorageArray = NULL;
3797 0 : if ( 0 < sizeOfActualPool )
3798 : {
3799 0 : SgMemberFunctionRefExpStorageArray = new SgMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
3800 0 : unsigned long storageClassIndex = SgMemberFunctionRefExp::initializeStorageClassArray (SgMemberFunctionRefExpStorageArray); ;
3801 0 : assert ( storageClassIndex == sizeOfActualPool );
3802 : }
3803 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMemberFunctionSymbol ) ;
3804 0 : std::cout << " SgMemberFunctionSymbol has size " << sizeOfActualPool << std::endl;
3805 0 : SgMemberFunctionSymbolStorageClass* SgMemberFunctionSymbolStorageArray = NULL;
3806 0 : if ( 0 < sizeOfActualPool )
3807 : {
3808 0 : SgMemberFunctionSymbolStorageArray = new SgMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
3809 0 : unsigned long storageClassIndex = SgMemberFunctionSymbol::initializeStorageClassArray (SgMemberFunctionSymbolStorageArray); ;
3810 0 : assert ( storageClassIndex == sizeOfActualPool );
3811 : }
3812 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMemberFunctionType ) ;
3813 0 : std::cout << " SgMemberFunctionType has size " << sizeOfActualPool << std::endl;
3814 0 : SgMemberFunctionTypeStorageClass* SgMemberFunctionTypeStorageArray = NULL;
3815 0 : if ( 0 < sizeOfActualPool )
3816 : {
3817 0 : SgMemberFunctionTypeStorageArray = new SgMemberFunctionTypeStorageClass[sizeOfActualPool] ;
3818 0 : unsigned long storageClassIndex = SgMemberFunctionType::initializeStorageClassArray (SgMemberFunctionTypeStorageArray); ;
3819 0 : assert ( storageClassIndex == sizeOfActualPool );
3820 : }
3821 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMembershipOp ) ;
3822 0 : std::cout << " SgMembershipOp has size " << sizeOfActualPool << std::endl;
3823 0 : SgMembershipOpStorageClass* SgMembershipOpStorageArray = NULL;
3824 0 : if ( 0 < sizeOfActualPool )
3825 : {
3826 0 : SgMembershipOpStorageArray = new SgMembershipOpStorageClass[sizeOfActualPool] ;
3827 0 : unsigned long storageClassIndex = SgMembershipOp::initializeStorageClassArray (SgMembershipOpStorageArray); ;
3828 0 : assert ( storageClassIndex == sizeOfActualPool );
3829 : }
3830 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMicrosoftAttributeDeclaration ) ;
3831 0 : std::cout << " SgMicrosoftAttributeDeclaration has size " << sizeOfActualPool << std::endl;
3832 0 : SgMicrosoftAttributeDeclarationStorageClass* SgMicrosoftAttributeDeclarationStorageArray = NULL;
3833 0 : if ( 0 < sizeOfActualPool )
3834 : {
3835 0 : SgMicrosoftAttributeDeclarationStorageArray = new SgMicrosoftAttributeDeclarationStorageClass[sizeOfActualPool] ;
3836 0 : unsigned long storageClassIndex = SgMicrosoftAttributeDeclaration::initializeStorageClassArray (SgMicrosoftAttributeDeclarationStorageArray); ;
3837 0 : assert ( storageClassIndex == sizeOfActualPool );
3838 : }
3839 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMinusAssignOp ) ;
3840 0 : std::cout << " SgMinusAssignOp has size " << sizeOfActualPool << std::endl;
3841 0 : SgMinusAssignOpStorageClass* SgMinusAssignOpStorageArray = NULL;
3842 0 : if ( 0 < sizeOfActualPool )
3843 : {
3844 0 : SgMinusAssignOpStorageArray = new SgMinusAssignOpStorageClass[sizeOfActualPool] ;
3845 0 : unsigned long storageClassIndex = SgMinusAssignOp::initializeStorageClassArray (SgMinusAssignOpStorageArray); ;
3846 0 : assert ( storageClassIndex == sizeOfActualPool );
3847 : }
3848 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMinusMinusOp ) ;
3849 0 : std::cout << " SgMinusMinusOp has size " << sizeOfActualPool << std::endl;
3850 0 : SgMinusMinusOpStorageClass* SgMinusMinusOpStorageArray = NULL;
3851 0 : if ( 0 < sizeOfActualPool )
3852 : {
3853 0 : SgMinusMinusOpStorageArray = new SgMinusMinusOpStorageClass[sizeOfActualPool] ;
3854 0 : unsigned long storageClassIndex = SgMinusMinusOp::initializeStorageClassArray (SgMinusMinusOpStorageArray); ;
3855 0 : assert ( storageClassIndex == sizeOfActualPool );
3856 : }
3857 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMinusOp ) ;
3858 0 : std::cout << " SgMinusOp has size " << sizeOfActualPool << std::endl;
3859 0 : SgMinusOpStorageClass* SgMinusOpStorageArray = NULL;
3860 0 : if ( 0 < sizeOfActualPool )
3861 : {
3862 0 : SgMinusOpStorageArray = new SgMinusOpStorageClass[sizeOfActualPool] ;
3863 0 : unsigned long storageClassIndex = SgMinusOp::initializeStorageClassArray (SgMinusOpStorageArray); ;
3864 0 : assert ( storageClassIndex == sizeOfActualPool );
3865 : }
3866 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModAssignOp ) ;
3867 0 : std::cout << " SgModAssignOp has size " << sizeOfActualPool << std::endl;
3868 0 : SgModAssignOpStorageClass* SgModAssignOpStorageArray = NULL;
3869 0 : if ( 0 < sizeOfActualPool )
3870 : {
3871 0 : SgModAssignOpStorageArray = new SgModAssignOpStorageClass[sizeOfActualPool] ;
3872 0 : unsigned long storageClassIndex = SgModAssignOp::initializeStorageClassArray (SgModAssignOpStorageArray); ;
3873 0 : assert ( storageClassIndex == sizeOfActualPool );
3874 : }
3875 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModOp ) ;
3876 0 : std::cout << " SgModOp has size " << sizeOfActualPool << std::endl;
3877 0 : SgModOpStorageClass* SgModOpStorageArray = NULL;
3878 0 : if ( 0 < sizeOfActualPool )
3879 : {
3880 0 : SgModOpStorageArray = new SgModOpStorageClass[sizeOfActualPool] ;
3881 0 : unsigned long storageClassIndex = SgModOp::initializeStorageClassArray (SgModOpStorageArray); ;
3882 0 : assert ( storageClassIndex == sizeOfActualPool );
3883 : }
3884 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModifier ) ;
3885 0 : std::cout << " SgModifier has size " << sizeOfActualPool << std::endl;
3886 0 : SgModifierStorageClass* SgModifierStorageArray = NULL;
3887 0 : if ( 0 < sizeOfActualPool )
3888 : {
3889 0 : SgModifierStorageArray = new SgModifierStorageClass[sizeOfActualPool] ;
3890 0 : unsigned long storageClassIndex = SgModifier::initializeStorageClassArray (SgModifierStorageArray); ;
3891 0 : assert ( storageClassIndex == sizeOfActualPool );
3892 : }
3893 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModifierNodes ) ;
3894 0 : std::cout << " SgModifierNodes has size " << sizeOfActualPool << std::endl;
3895 0 : SgModifierNodesStorageClass* SgModifierNodesStorageArray = NULL;
3896 0 : if ( 0 < sizeOfActualPool )
3897 : {
3898 0 : SgModifierNodesStorageArray = new SgModifierNodesStorageClass[sizeOfActualPool] ;
3899 0 : unsigned long storageClassIndex = SgModifierNodes::initializeStorageClassArray (SgModifierNodesStorageArray); ;
3900 0 : assert ( storageClassIndex == sizeOfActualPool );
3901 : }
3902 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModifierType ) ;
3903 0 : std::cout << " SgModifierType has size " << sizeOfActualPool << std::endl;
3904 0 : SgModifierTypeStorageClass* SgModifierTypeStorageArray = NULL;
3905 0 : if ( 0 < sizeOfActualPool )
3906 : {
3907 0 : SgModifierTypeStorageArray = new SgModifierTypeStorageClass[sizeOfActualPool] ;
3908 0 : unsigned long storageClassIndex = SgModifierType::initializeStorageClassArray (SgModifierTypeStorageArray); ;
3909 0 : assert ( storageClassIndex == sizeOfActualPool );
3910 : }
3911 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModuleStatement ) ;
3912 0 : std::cout << " SgModuleStatement has size " << sizeOfActualPool << std::endl;
3913 0 : SgModuleStatementStorageClass* SgModuleStatementStorageArray = NULL;
3914 0 : if ( 0 < sizeOfActualPool )
3915 : {
3916 0 : SgModuleStatementStorageArray = new SgModuleStatementStorageClass[sizeOfActualPool] ;
3917 0 : unsigned long storageClassIndex = SgModuleStatement::initializeStorageClassArray (SgModuleStatementStorageArray); ;
3918 0 : assert ( storageClassIndex == sizeOfActualPool );
3919 : }
3920 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgModuleSymbol ) ;
3921 0 : std::cout << " SgModuleSymbol has size " << sizeOfActualPool << std::endl;
3922 0 : SgModuleSymbolStorageClass* SgModuleSymbolStorageArray = NULL;
3923 0 : if ( 0 < sizeOfActualPool )
3924 : {
3925 0 : SgModuleSymbolStorageArray = new SgModuleSymbolStorageClass[sizeOfActualPool] ;
3926 0 : unsigned long storageClassIndex = SgModuleSymbol::initializeStorageClassArray (SgModuleSymbolStorageArray); ;
3927 0 : assert ( storageClassIndex == sizeOfActualPool );
3928 : }
3929 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMultAssignOp ) ;
3930 0 : std::cout << " SgMultAssignOp has size " << sizeOfActualPool << std::endl;
3931 0 : SgMultAssignOpStorageClass* SgMultAssignOpStorageArray = NULL;
3932 0 : if ( 0 < sizeOfActualPool )
3933 : {
3934 0 : SgMultAssignOpStorageArray = new SgMultAssignOpStorageClass[sizeOfActualPool] ;
3935 0 : unsigned long storageClassIndex = SgMultAssignOp::initializeStorageClassArray (SgMultAssignOpStorageArray); ;
3936 0 : assert ( storageClassIndex == sizeOfActualPool );
3937 : }
3938 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgMultiplyOp ) ;
3939 0 : std::cout << " SgMultiplyOp has size " << sizeOfActualPool << std::endl;
3940 0 : SgMultiplyOpStorageClass* SgMultiplyOpStorageArray = NULL;
3941 0 : if ( 0 < sizeOfActualPool )
3942 : {
3943 0 : SgMultiplyOpStorageArray = new SgMultiplyOpStorageClass[sizeOfActualPool] ;
3944 0 : unsigned long storageClassIndex = SgMultiplyOp::initializeStorageClassArray (SgMultiplyOpStorageArray); ;
3945 0 : assert ( storageClassIndex == sizeOfActualPool );
3946 : }
3947 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgName ) ;
3948 0 : std::cout << " SgName has size " << sizeOfActualPool << std::endl;
3949 0 : SgNameStorageClass* SgNameStorageArray = NULL;
3950 0 : if ( 0 < sizeOfActualPool )
3951 : {
3952 0 : SgNameStorageArray = new SgNameStorageClass[sizeOfActualPool] ;
3953 0 : unsigned long storageClassIndex = SgName::initializeStorageClassArray (SgNameStorageArray); ;
3954 0 : assert ( storageClassIndex == sizeOfActualPool );
3955 : }
3956 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNameGroup ) ;
3957 0 : std::cout << " SgNameGroup has size " << sizeOfActualPool << std::endl;
3958 0 : SgNameGroupStorageClass* SgNameGroupStorageArray = NULL;
3959 0 : if ( 0 < sizeOfActualPool )
3960 : {
3961 0 : SgNameGroupStorageArray = new SgNameGroupStorageClass[sizeOfActualPool] ;
3962 0 : unsigned long storageClassIndex = SgNameGroup::initializeStorageClassArray (SgNameGroupStorageArray); ;
3963 0 : assert ( storageClassIndex == sizeOfActualPool );
3964 : }
3965 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamedType ) ;
3966 0 : std::cout << " SgNamedType has size " << sizeOfActualPool << std::endl;
3967 0 : SgNamedTypeStorageClass* SgNamedTypeStorageArray = NULL;
3968 0 : if ( 0 < sizeOfActualPool )
3969 : {
3970 0 : SgNamedTypeStorageArray = new SgNamedTypeStorageClass[sizeOfActualPool] ;
3971 0 : unsigned long storageClassIndex = SgNamedType::initializeStorageClassArray (SgNamedTypeStorageArray); ;
3972 0 : assert ( storageClassIndex == sizeOfActualPool );
3973 : }
3974 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamelistStatement ) ;
3975 0 : std::cout << " SgNamelistStatement has size " << sizeOfActualPool << std::endl;
3976 0 : SgNamelistStatementStorageClass* SgNamelistStatementStorageArray = NULL;
3977 0 : if ( 0 < sizeOfActualPool )
3978 : {
3979 0 : SgNamelistStatementStorageArray = new SgNamelistStatementStorageClass[sizeOfActualPool] ;
3980 0 : unsigned long storageClassIndex = SgNamelistStatement::initializeStorageClassArray (SgNamelistStatementStorageArray); ;
3981 0 : assert ( storageClassIndex == sizeOfActualPool );
3982 : }
3983 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamespaceAliasDeclarationStatement ) ;
3984 0 : std::cout << " SgNamespaceAliasDeclarationStatement has size " << sizeOfActualPool << std::endl;
3985 0 : SgNamespaceAliasDeclarationStatementStorageClass* SgNamespaceAliasDeclarationStatementStorageArray = NULL;
3986 0 : if ( 0 < sizeOfActualPool )
3987 : {
3988 0 : SgNamespaceAliasDeclarationStatementStorageArray = new SgNamespaceAliasDeclarationStatementStorageClass[sizeOfActualPool] ;
3989 0 : unsigned long storageClassIndex = SgNamespaceAliasDeclarationStatement::initializeStorageClassArray (SgNamespaceAliasDeclarationStatementStorageArray); ;
3990 0 : assert ( storageClassIndex == sizeOfActualPool );
3991 : }
3992 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamespaceDeclarationStatement ) ;
3993 0 : std::cout << " SgNamespaceDeclarationStatement has size " << sizeOfActualPool << std::endl;
3994 0 : SgNamespaceDeclarationStatementStorageClass* SgNamespaceDeclarationStatementStorageArray = NULL;
3995 0 : if ( 0 < sizeOfActualPool )
3996 : {
3997 0 : SgNamespaceDeclarationStatementStorageArray = new SgNamespaceDeclarationStatementStorageClass[sizeOfActualPool] ;
3998 0 : unsigned long storageClassIndex = SgNamespaceDeclarationStatement::initializeStorageClassArray (SgNamespaceDeclarationStatementStorageArray); ;
3999 0 : assert ( storageClassIndex == sizeOfActualPool );
4000 : }
4001 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamespaceDefinitionStatement ) ;
4002 0 : std::cout << " SgNamespaceDefinitionStatement has size " << sizeOfActualPool << std::endl;
4003 0 : SgNamespaceDefinitionStatementStorageClass* SgNamespaceDefinitionStatementStorageArray = NULL;
4004 0 : if ( 0 < sizeOfActualPool )
4005 : {
4006 0 : SgNamespaceDefinitionStatementStorageArray = new SgNamespaceDefinitionStatementStorageClass[sizeOfActualPool] ;
4007 0 : unsigned long storageClassIndex = SgNamespaceDefinitionStatement::initializeStorageClassArray (SgNamespaceDefinitionStatementStorageArray); ;
4008 0 : assert ( storageClassIndex == sizeOfActualPool );
4009 : }
4010 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNamespaceSymbol ) ;
4011 0 : std::cout << " SgNamespaceSymbol has size " << sizeOfActualPool << std::endl;
4012 0 : SgNamespaceSymbolStorageClass* SgNamespaceSymbolStorageArray = NULL;
4013 0 : if ( 0 < sizeOfActualPool )
4014 : {
4015 0 : SgNamespaceSymbolStorageArray = new SgNamespaceSymbolStorageClass[sizeOfActualPool] ;
4016 0 : unsigned long storageClassIndex = SgNamespaceSymbol::initializeStorageClassArray (SgNamespaceSymbolStorageArray); ;
4017 0 : assert ( storageClassIndex == sizeOfActualPool );
4018 : }
4019 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNaryOp ) ;
4020 0 : std::cout << " SgNaryOp has size " << sizeOfActualPool << std::endl;
4021 0 : SgNaryOpStorageClass* SgNaryOpStorageArray = NULL;
4022 0 : if ( 0 < sizeOfActualPool )
4023 : {
4024 0 : SgNaryOpStorageArray = new SgNaryOpStorageClass[sizeOfActualPool] ;
4025 0 : unsigned long storageClassIndex = SgNaryOp::initializeStorageClassArray (SgNaryOpStorageArray); ;
4026 0 : assert ( storageClassIndex == sizeOfActualPool );
4027 : }
4028 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNaryBooleanOp ) ;
4029 0 : std::cout << " SgNaryBooleanOp has size " << sizeOfActualPool << std::endl;
4030 0 : SgNaryBooleanOpStorageClass* SgNaryBooleanOpStorageArray = NULL;
4031 0 : if ( 0 < sizeOfActualPool )
4032 : {
4033 0 : SgNaryBooleanOpStorageArray = new SgNaryBooleanOpStorageClass[sizeOfActualPool] ;
4034 0 : unsigned long storageClassIndex = SgNaryBooleanOp::initializeStorageClassArray (SgNaryBooleanOpStorageArray); ;
4035 0 : assert ( storageClassIndex == sizeOfActualPool );
4036 : }
4037 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNaryComparisonOp ) ;
4038 0 : std::cout << " SgNaryComparisonOp has size " << sizeOfActualPool << std::endl;
4039 0 : SgNaryComparisonOpStorageClass* SgNaryComparisonOpStorageArray = NULL;
4040 0 : if ( 0 < sizeOfActualPool )
4041 : {
4042 0 : SgNaryComparisonOpStorageArray = new SgNaryComparisonOpStorageClass[sizeOfActualPool] ;
4043 0 : unsigned long storageClassIndex = SgNaryComparisonOp::initializeStorageClassArray (SgNaryComparisonOpStorageArray); ;
4044 0 : assert ( storageClassIndex == sizeOfActualPool );
4045 : }
4046 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNewExp ) ;
4047 0 : std::cout << " SgNewExp has size " << sizeOfActualPool << std::endl;
4048 0 : SgNewExpStorageClass* SgNewExpStorageArray = NULL;
4049 0 : if ( 0 < sizeOfActualPool )
4050 : {
4051 0 : SgNewExpStorageArray = new SgNewExpStorageClass[sizeOfActualPool] ;
4052 0 : unsigned long storageClassIndex = SgNewExp::initializeStorageClassArray (SgNewExpStorageArray); ;
4053 0 : assert ( storageClassIndex == sizeOfActualPool );
4054 : }
4055 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNode ) ;
4056 0 : std::cout << " SgNode has size " << sizeOfActualPool << std::endl;
4057 0 : SgNodeStorageClass* SgNodeStorageArray = NULL;
4058 0 : if ( 0 < sizeOfActualPool )
4059 : {
4060 0 : SgNodeStorageArray = new SgNodeStorageClass[sizeOfActualPool] ;
4061 0 : unsigned long storageClassIndex = SgNode::initializeStorageClassArray (SgNodeStorageArray); ;
4062 0 : assert ( storageClassIndex == sizeOfActualPool );
4063 : }
4064 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNoexceptOp ) ;
4065 0 : std::cout << " SgNoexceptOp has size " << sizeOfActualPool << std::endl;
4066 0 : SgNoexceptOpStorageClass* SgNoexceptOpStorageArray = NULL;
4067 0 : if ( 0 < sizeOfActualPool )
4068 : {
4069 0 : SgNoexceptOpStorageArray = new SgNoexceptOpStorageClass[sizeOfActualPool] ;
4070 0 : unsigned long storageClassIndex = SgNoexceptOp::initializeStorageClassArray (SgNoexceptOpStorageArray); ;
4071 0 : assert ( storageClassIndex == sizeOfActualPool );
4072 : }
4073 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNotEqualOp ) ;
4074 0 : std::cout << " SgNotEqualOp has size " << sizeOfActualPool << std::endl;
4075 0 : SgNotEqualOpStorageClass* SgNotEqualOpStorageArray = NULL;
4076 0 : if ( 0 < sizeOfActualPool )
4077 : {
4078 0 : SgNotEqualOpStorageArray = new SgNotEqualOpStorageClass[sizeOfActualPool] ;
4079 0 : unsigned long storageClassIndex = SgNotEqualOp::initializeStorageClassArray (SgNotEqualOpStorageArray); ;
4080 0 : assert ( storageClassIndex == sizeOfActualPool );
4081 : }
4082 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNotOp ) ;
4083 0 : std::cout << " SgNotOp has size " << sizeOfActualPool << std::endl;
4084 0 : SgNotOpStorageClass* SgNotOpStorageArray = NULL;
4085 0 : if ( 0 < sizeOfActualPool )
4086 : {
4087 0 : SgNotOpStorageArray = new SgNotOpStorageClass[sizeOfActualPool] ;
4088 0 : unsigned long storageClassIndex = SgNotOp::initializeStorageClassArray (SgNotOpStorageArray); ;
4089 0 : assert ( storageClassIndex == sizeOfActualPool );
4090 : }
4091 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonMembershipOp ) ;
4092 0 : std::cout << " SgNonMembershipOp has size " << sizeOfActualPool << std::endl;
4093 0 : SgNonMembershipOpStorageClass* SgNonMembershipOpStorageArray = NULL;
4094 0 : if ( 0 < sizeOfActualPool )
4095 : {
4096 0 : SgNonMembershipOpStorageArray = new SgNonMembershipOpStorageClass[sizeOfActualPool] ;
4097 0 : unsigned long storageClassIndex = SgNonMembershipOp::initializeStorageClassArray (SgNonMembershipOpStorageArray); ;
4098 0 : assert ( storageClassIndex == sizeOfActualPool );
4099 : }
4100 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonrealDecl ) ;
4101 0 : std::cout << " SgNonrealDecl has size " << sizeOfActualPool << std::endl;
4102 0 : SgNonrealDeclStorageClass* SgNonrealDeclStorageArray = NULL;
4103 0 : if ( 0 < sizeOfActualPool )
4104 : {
4105 0 : SgNonrealDeclStorageArray = new SgNonrealDeclStorageClass[sizeOfActualPool] ;
4106 0 : unsigned long storageClassIndex = SgNonrealDecl::initializeStorageClassArray (SgNonrealDeclStorageArray); ;
4107 0 : assert ( storageClassIndex == sizeOfActualPool );
4108 : }
4109 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonrealRefExp ) ;
4110 0 : std::cout << " SgNonrealRefExp has size " << sizeOfActualPool << std::endl;
4111 0 : SgNonrealRefExpStorageClass* SgNonrealRefExpStorageArray = NULL;
4112 0 : if ( 0 < sizeOfActualPool )
4113 : {
4114 0 : SgNonrealRefExpStorageArray = new SgNonrealRefExpStorageClass[sizeOfActualPool] ;
4115 0 : unsigned long storageClassIndex = SgNonrealRefExp::initializeStorageClassArray (SgNonrealRefExpStorageArray); ;
4116 0 : assert ( storageClassIndex == sizeOfActualPool );
4117 : }
4118 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonrealSymbol ) ;
4119 0 : std::cout << " SgNonrealSymbol has size " << sizeOfActualPool << std::endl;
4120 0 : SgNonrealSymbolStorageClass* SgNonrealSymbolStorageArray = NULL;
4121 0 : if ( 0 < sizeOfActualPool )
4122 : {
4123 0 : SgNonrealSymbolStorageArray = new SgNonrealSymbolStorageClass[sizeOfActualPool] ;
4124 0 : unsigned long storageClassIndex = SgNonrealSymbol::initializeStorageClassArray (SgNonrealSymbolStorageArray); ;
4125 0 : assert ( storageClassIndex == sizeOfActualPool );
4126 : }
4127 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonrealType ) ;
4128 0 : std::cout << " SgNonrealType has size " << sizeOfActualPool << std::endl;
4129 0 : SgNonrealTypeStorageClass* SgNonrealTypeStorageArray = NULL;
4130 0 : if ( 0 < sizeOfActualPool )
4131 : {
4132 0 : SgNonrealTypeStorageArray = new SgNonrealTypeStorageClass[sizeOfActualPool] ;
4133 0 : unsigned long storageClassIndex = SgNonrealType::initializeStorageClassArray (SgNonrealTypeStorageArray); ;
4134 0 : assert ( storageClassIndex == sizeOfActualPool );
4135 : }
4136 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNonrealBaseClass ) ;
4137 0 : std::cout << " SgNonrealBaseClass has size " << sizeOfActualPool << std::endl;
4138 0 : SgNonrealBaseClassStorageClass* SgNonrealBaseClassStorageArray = NULL;
4139 0 : if ( 0 < sizeOfActualPool )
4140 : {
4141 0 : SgNonrealBaseClassStorageArray = new SgNonrealBaseClassStorageClass[sizeOfActualPool] ;
4142 0 : unsigned long storageClassIndex = SgNonrealBaseClass::initializeStorageClassArray (SgNonrealBaseClassStorageArray); ;
4143 0 : assert ( storageClassIndex == sizeOfActualPool );
4144 : }
4145 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNullExpression ) ;
4146 0 : std::cout << " SgNullExpression has size " << sizeOfActualPool << std::endl;
4147 0 : SgNullExpressionStorageClass* SgNullExpressionStorageArray = NULL;
4148 0 : if ( 0 < sizeOfActualPool )
4149 : {
4150 0 : SgNullExpressionStorageArray = new SgNullExpressionStorageClass[sizeOfActualPool] ;
4151 0 : unsigned long storageClassIndex = SgNullExpression::initializeStorageClassArray (SgNullExpressionStorageArray); ;
4152 0 : assert ( storageClassIndex == sizeOfActualPool );
4153 : }
4154 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNullptrValExp ) ;
4155 0 : std::cout << " SgNullptrValExp has size " << sizeOfActualPool << std::endl;
4156 0 : SgNullptrValExpStorageClass* SgNullptrValExpStorageArray = NULL;
4157 0 : if ( 0 < sizeOfActualPool )
4158 : {
4159 0 : SgNullptrValExpStorageArray = new SgNullptrValExpStorageClass[sizeOfActualPool] ;
4160 0 : unsigned long storageClassIndex = SgNullptrValExp::initializeStorageClassArray (SgNullptrValExpStorageArray); ;
4161 0 : assert ( storageClassIndex == sizeOfActualPool );
4162 : }
4163 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNullStatement ) ;
4164 0 : std::cout << " SgNullStatement has size " << sizeOfActualPool << std::endl;
4165 0 : SgNullStatementStorageClass* SgNullStatementStorageArray = NULL;
4166 0 : if ( 0 < sizeOfActualPool )
4167 : {
4168 0 : SgNullStatementStorageArray = new SgNullStatementStorageClass[sizeOfActualPool] ;
4169 0 : unsigned long storageClassIndex = SgNullStatement::initializeStorageClassArray (SgNullStatementStorageArray); ;
4170 0 : assert ( storageClassIndex == sizeOfActualPool );
4171 : }
4172 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgNullifyStatement ) ;
4173 0 : std::cout << " SgNullifyStatement has size " << sizeOfActualPool << std::endl;
4174 0 : SgNullifyStatementStorageClass* SgNullifyStatementStorageArray = NULL;
4175 0 : if ( 0 < sizeOfActualPool )
4176 : {
4177 0 : SgNullifyStatementStorageArray = new SgNullifyStatementStorageClass[sizeOfActualPool] ;
4178 0 : unsigned long storageClassIndex = SgNullifyStatement::initializeStorageClassArray (SgNullifyStatementStorageArray); ;
4179 0 : assert ( storageClassIndex == sizeOfActualPool );
4180 : }
4181 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAtomicStatement ) ;
4182 0 : std::cout << " SgOmpAtomicStatement has size " << sizeOfActualPool << std::endl;
4183 0 : SgOmpAtomicStatementStorageClass* SgOmpAtomicStatementStorageArray = NULL;
4184 0 : if ( 0 < sizeOfActualPool )
4185 : {
4186 0 : SgOmpAtomicStatementStorageArray = new SgOmpAtomicStatementStorageClass[sizeOfActualPool] ;
4187 0 : unsigned long storageClassIndex = SgOmpAtomicStatement::initializeStorageClassArray (SgOmpAtomicStatementStorageArray); ;
4188 0 : assert ( storageClassIndex == sizeOfActualPool );
4189 : }
4190 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpBarrierStatement ) ;
4191 0 : std::cout << " SgOmpBarrierStatement has size " << sizeOfActualPool << std::endl;
4192 0 : SgOmpBarrierStatementStorageClass* SgOmpBarrierStatementStorageArray = NULL;
4193 0 : if ( 0 < sizeOfActualPool )
4194 : {
4195 0 : SgOmpBarrierStatementStorageArray = new SgOmpBarrierStatementStorageClass[sizeOfActualPool] ;
4196 0 : unsigned long storageClassIndex = SgOmpBarrierStatement::initializeStorageClassArray (SgOmpBarrierStatementStorageArray); ;
4197 0 : assert ( storageClassIndex == sizeOfActualPool );
4198 : }
4199 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCriticalStatement ) ;
4200 0 : std::cout << " SgOmpCriticalStatement has size " << sizeOfActualPool << std::endl;
4201 0 : SgOmpCriticalStatementStorageClass* SgOmpCriticalStatementStorageArray = NULL;
4202 0 : if ( 0 < sizeOfActualPool )
4203 : {
4204 0 : SgOmpCriticalStatementStorageArray = new SgOmpCriticalStatementStorageClass[sizeOfActualPool] ;
4205 0 : unsigned long storageClassIndex = SgOmpCriticalStatement::initializeStorageClassArray (SgOmpCriticalStatementStorageArray); ;
4206 0 : assert ( storageClassIndex == sizeOfActualPool );
4207 : }
4208 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirFieldBodyStatement ) ;
4209 0 : std::cout << " SgUpirFieldBodyStatement has size " << sizeOfActualPool << std::endl;
4210 0 : SgUpirFieldBodyStatementStorageClass* SgUpirFieldBodyStatementStorageArray = NULL;
4211 0 : if ( 0 < sizeOfActualPool )
4212 : {
4213 0 : SgUpirFieldBodyStatementStorageArray = new SgUpirFieldBodyStatementStorageClass[sizeOfActualPool] ;
4214 0 : unsigned long storageClassIndex = SgUpirFieldBodyStatement::initializeStorageClassArray (SgUpirFieldBodyStatementStorageArray); ;
4215 0 : assert ( storageClassIndex == sizeOfActualPool );
4216 : }
4217 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirBodyStatement ) ;
4218 0 : std::cout << " SgUpirBodyStatement has size " << sizeOfActualPool << std::endl;
4219 0 : SgUpirBodyStatementStorageClass* SgUpirBodyStatementStorageArray = NULL;
4220 0 : if ( 0 < sizeOfActualPool )
4221 : {
4222 0 : SgUpirBodyStatementStorageArray = new SgUpirBodyStatementStorageClass[sizeOfActualPool] ;
4223 0 : unsigned long storageClassIndex = SgUpirBodyStatement::initializeStorageClassArray (SgUpirBodyStatementStorageArray); ;
4224 0 : assert ( storageClassIndex == sizeOfActualPool );
4225 : }
4226 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirFieldStatement ) ;
4227 0 : std::cout << " SgUpirFieldStatement has size " << sizeOfActualPool << std::endl;
4228 0 : SgUpirFieldStatementStorageClass* SgUpirFieldStatementStorageArray = NULL;
4229 0 : if ( 0 < sizeOfActualPool )
4230 : {
4231 0 : SgUpirFieldStatementStorageArray = new SgUpirFieldStatementStorageClass[sizeOfActualPool] ;
4232 0 : unsigned long storageClassIndex = SgUpirFieldStatement::initializeStorageClassArray (SgUpirFieldStatementStorageArray); ;
4233 0 : assert ( storageClassIndex == sizeOfActualPool );
4234 : }
4235 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDoStatement ) ;
4236 0 : std::cout << " SgOmpDoStatement has size " << sizeOfActualPool << std::endl;
4237 0 : SgOmpDoStatementStorageClass* SgOmpDoStatementStorageArray = NULL;
4238 0 : if ( 0 < sizeOfActualPool )
4239 : {
4240 0 : SgOmpDoStatementStorageArray = new SgOmpDoStatementStorageClass[sizeOfActualPool] ;
4241 0 : unsigned long storageClassIndex = SgOmpDoStatement::initializeStorageClassArray (SgOmpDoStatementStorageArray); ;
4242 0 : assert ( storageClassIndex == sizeOfActualPool );
4243 : }
4244 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpFlushStatement ) ;
4245 0 : std::cout << " SgOmpFlushStatement has size " << sizeOfActualPool << std::endl;
4246 0 : SgOmpFlushStatementStorageClass* SgOmpFlushStatementStorageArray = NULL;
4247 0 : if ( 0 < sizeOfActualPool )
4248 : {
4249 0 : SgOmpFlushStatementStorageArray = new SgOmpFlushStatementStorageClass[sizeOfActualPool] ;
4250 0 : unsigned long storageClassIndex = SgOmpFlushStatement::initializeStorageClassArray (SgOmpFlushStatementStorageArray); ;
4251 0 : assert ( storageClassIndex == sizeOfActualPool );
4252 : }
4253 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAllocateStatement ) ;
4254 0 : std::cout << " SgOmpAllocateStatement has size " << sizeOfActualPool << std::endl;
4255 0 : SgOmpAllocateStatementStorageClass* SgOmpAllocateStatementStorageArray = NULL;
4256 0 : if ( 0 < sizeOfActualPool )
4257 : {
4258 0 : SgOmpAllocateStatementStorageArray = new SgOmpAllocateStatementStorageClass[sizeOfActualPool] ;
4259 0 : unsigned long storageClassIndex = SgOmpAllocateStatement::initializeStorageClassArray (SgOmpAllocateStatementStorageArray); ;
4260 0 : assert ( storageClassIndex == sizeOfActualPool );
4261 : }
4262 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDeclareSimdStatement ) ;
4263 0 : std::cout << " SgOmpDeclareSimdStatement has size " << sizeOfActualPool << std::endl;
4264 0 : SgOmpDeclareSimdStatementStorageClass* SgOmpDeclareSimdStatementStorageArray = NULL;
4265 0 : if ( 0 < sizeOfActualPool )
4266 : {
4267 0 : SgOmpDeclareSimdStatementStorageArray = new SgOmpDeclareSimdStatementStorageClass[sizeOfActualPool] ;
4268 0 : unsigned long storageClassIndex = SgOmpDeclareSimdStatement::initializeStorageClassArray (SgOmpDeclareSimdStatementStorageArray); ;
4269 0 : assert ( storageClassIndex == sizeOfActualPool );
4270 : }
4271 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirWorksharingStatement ) ;
4272 0 : std::cout << " SgUpirWorksharingStatement has size " << sizeOfActualPool << std::endl;
4273 0 : SgUpirWorksharingStatementStorageClass* SgUpirWorksharingStatementStorageArray = NULL;
4274 0 : if ( 0 < sizeOfActualPool )
4275 : {
4276 0 : SgUpirWorksharingStatementStorageArray = new SgUpirWorksharingStatementStorageClass[sizeOfActualPool] ;
4277 0 : unsigned long storageClassIndex = SgUpirWorksharingStatement::initializeStorageClassArray (SgUpirWorksharingStatementStorageArray); ;
4278 0 : assert ( storageClassIndex == sizeOfActualPool );
4279 : }
4280 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpForSimdStatement ) ;
4281 0 : std::cout << " SgOmpForSimdStatement has size " << sizeOfActualPool << std::endl;
4282 0 : SgOmpForSimdStatementStorageClass* SgOmpForSimdStatementStorageArray = NULL;
4283 0 : if ( 0 < sizeOfActualPool )
4284 : {
4285 0 : SgOmpForSimdStatementStorageArray = new SgOmpForSimdStatementStorageClass[sizeOfActualPool] ;
4286 0 : unsigned long storageClassIndex = SgOmpForSimdStatement::initializeStorageClassArray (SgOmpForSimdStatementStorageArray); ;
4287 0 : assert ( storageClassIndex == sizeOfActualPool );
4288 : }
4289 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMasterStatement ) ;
4290 0 : std::cout << " SgOmpMasterStatement has size " << sizeOfActualPool << std::endl;
4291 0 : SgOmpMasterStatementStorageClass* SgOmpMasterStatementStorageArray = NULL;
4292 0 : if ( 0 < sizeOfActualPool )
4293 : {
4294 0 : SgOmpMasterStatementStorageArray = new SgOmpMasterStatementStorageClass[sizeOfActualPool] ;
4295 0 : unsigned long storageClassIndex = SgOmpMasterStatement::initializeStorageClassArray (SgOmpMasterStatementStorageArray); ;
4296 0 : assert ( storageClassIndex == sizeOfActualPool );
4297 : }
4298 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskyieldStatement ) ;
4299 0 : std::cout << " SgOmpTaskyieldStatement has size " << sizeOfActualPool << std::endl;
4300 0 : SgOmpTaskyieldStatementStorageClass* SgOmpTaskyieldStatementStorageArray = NULL;
4301 0 : if ( 0 < sizeOfActualPool )
4302 : {
4303 0 : SgOmpTaskyieldStatementStorageArray = new SgOmpTaskyieldStatementStorageClass[sizeOfActualPool] ;
4304 0 : unsigned long storageClassIndex = SgOmpTaskyieldStatement::initializeStorageClassArray (SgOmpTaskyieldStatementStorageArray); ;
4305 0 : assert ( storageClassIndex == sizeOfActualPool );
4306 : }
4307 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMetadirectiveStatement ) ;
4308 0 : std::cout << " SgOmpMetadirectiveStatement has size " << sizeOfActualPool << std::endl;
4309 0 : SgOmpMetadirectiveStatementStorageClass* SgOmpMetadirectiveStatementStorageArray = NULL;
4310 0 : if ( 0 < sizeOfActualPool )
4311 : {
4312 0 : SgOmpMetadirectiveStatementStorageArray = new SgOmpMetadirectiveStatementStorageClass[sizeOfActualPool] ;
4313 0 : unsigned long storageClassIndex = SgOmpMetadirectiveStatement::initializeStorageClassArray (SgOmpMetadirectiveStatementStorageArray); ;
4314 0 : assert ( storageClassIndex == sizeOfActualPool );
4315 : }
4316 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpOrderedStatement ) ;
4317 0 : std::cout << " SgOmpOrderedStatement has size " << sizeOfActualPool << std::endl;
4318 0 : SgOmpOrderedStatementStorageClass* SgOmpOrderedStatementStorageArray = NULL;
4319 0 : if ( 0 < sizeOfActualPool )
4320 : {
4321 0 : SgOmpOrderedStatementStorageArray = new SgOmpOrderedStatementStorageClass[sizeOfActualPool] ;
4322 0 : unsigned long storageClassIndex = SgOmpOrderedStatement::initializeStorageClassArray (SgOmpOrderedStatementStorageArray); ;
4323 0 : assert ( storageClassIndex == sizeOfActualPool );
4324 : }
4325 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpOrderedDependStatement ) ;
4326 0 : std::cout << " SgOmpOrderedDependStatement has size " << sizeOfActualPool << std::endl;
4327 0 : SgOmpOrderedDependStatementStorageClass* SgOmpOrderedDependStatementStorageArray = NULL;
4328 0 : if ( 0 < sizeOfActualPool )
4329 : {
4330 0 : SgOmpOrderedDependStatementStorageArray = new SgOmpOrderedDependStatementStorageClass[sizeOfActualPool] ;
4331 0 : unsigned long storageClassIndex = SgOmpOrderedDependStatement::initializeStorageClassArray (SgOmpOrderedDependStatementStorageArray); ;
4332 0 : assert ( storageClassIndex == sizeOfActualPool );
4333 : }
4334 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirSpmdStatement ) ;
4335 0 : std::cout << " SgUpirSpmdStatement has size " << sizeOfActualPool << std::endl;
4336 0 : SgUpirSpmdStatementStorageClass* SgUpirSpmdStatementStorageArray = NULL;
4337 0 : if ( 0 < sizeOfActualPool )
4338 : {
4339 0 : SgUpirSpmdStatementStorageArray = new SgUpirSpmdStatementStorageClass[sizeOfActualPool] ;
4340 0 : unsigned long storageClassIndex = SgUpirSpmdStatement::initializeStorageClassArray (SgUpirSpmdStatementStorageArray); ;
4341 0 : assert ( storageClassIndex == sizeOfActualPool );
4342 : }
4343 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsStatement ) ;
4344 0 : std::cout << " SgOmpTeamsStatement has size " << sizeOfActualPool << std::endl;
4345 0 : SgOmpTeamsStatementStorageClass* SgOmpTeamsStatementStorageArray = NULL;
4346 0 : if ( 0 < sizeOfActualPool )
4347 : {
4348 0 : SgOmpTeamsStatementStorageArray = new SgOmpTeamsStatementStorageClass[sizeOfActualPool] ;
4349 0 : unsigned long storageClassIndex = SgOmpTeamsStatement::initializeStorageClassArray (SgOmpTeamsStatementStorageArray); ;
4350 0 : assert ( storageClassIndex == sizeOfActualPool );
4351 : }
4352 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCancellationPointStatement ) ;
4353 0 : std::cout << " SgOmpCancellationPointStatement has size " << sizeOfActualPool << std::endl;
4354 0 : SgOmpCancellationPointStatementStorageClass* SgOmpCancellationPointStatementStorageArray = NULL;
4355 0 : if ( 0 < sizeOfActualPool )
4356 : {
4357 0 : SgOmpCancellationPointStatementStorageArray = new SgOmpCancellationPointStatementStorageClass[sizeOfActualPool] ;
4358 0 : unsigned long storageClassIndex = SgOmpCancellationPointStatement::initializeStorageClassArray (SgOmpCancellationPointStatementStorageArray); ;
4359 0 : assert ( storageClassIndex == sizeOfActualPool );
4360 : }
4361 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDeclareMapperStatement ) ;
4362 0 : std::cout << " SgOmpDeclareMapperStatement has size " << sizeOfActualPool << std::endl;
4363 0 : SgOmpDeclareMapperStatementStorageClass* SgOmpDeclareMapperStatementStorageArray = NULL;
4364 0 : if ( 0 < sizeOfActualPool )
4365 : {
4366 0 : SgOmpDeclareMapperStatementStorageArray = new SgOmpDeclareMapperStatementStorageClass[sizeOfActualPool] ;
4367 0 : unsigned long storageClassIndex = SgOmpDeclareMapperStatement::initializeStorageClassArray (SgOmpDeclareMapperStatementStorageArray); ;
4368 0 : assert ( storageClassIndex == sizeOfActualPool );
4369 : }
4370 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCancelStatement ) ;
4371 0 : std::cout << " SgOmpCancelStatement has size " << sizeOfActualPool << std::endl;
4372 0 : SgOmpCancelStatementStorageClass* SgOmpCancelStatementStorageArray = NULL;
4373 0 : if ( 0 < sizeOfActualPool )
4374 : {
4375 0 : SgOmpCancelStatementStorageArray = new SgOmpCancelStatementStorageClass[sizeOfActualPool] ;
4376 0 : unsigned long storageClassIndex = SgOmpCancelStatement::initializeStorageClassArray (SgOmpCancelStatementStorageArray); ;
4377 0 : assert ( storageClassIndex == sizeOfActualPool );
4378 : }
4379 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskgroupStatement ) ;
4380 0 : std::cout << " SgOmpTaskgroupStatement has size " << sizeOfActualPool << std::endl;
4381 0 : SgOmpTaskgroupStatementStorageClass* SgOmpTaskgroupStatementStorageArray = NULL;
4382 0 : if ( 0 < sizeOfActualPool )
4383 : {
4384 0 : SgOmpTaskgroupStatementStorageArray = new SgOmpTaskgroupStatementStorageClass[sizeOfActualPool] ;
4385 0 : unsigned long storageClassIndex = SgOmpTaskgroupStatement::initializeStorageClassArray (SgOmpTaskgroupStatementStorageArray); ;
4386 0 : assert ( storageClassIndex == sizeOfActualPool );
4387 : }
4388 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDepobjStatement ) ;
4389 0 : std::cout << " SgOmpDepobjStatement has size " << sizeOfActualPool << std::endl;
4390 0 : SgOmpDepobjStatementStorageClass* SgOmpDepobjStatementStorageArray = NULL;
4391 0 : if ( 0 < sizeOfActualPool )
4392 : {
4393 0 : SgOmpDepobjStatementStorageArray = new SgOmpDepobjStatementStorageClass[sizeOfActualPool] ;
4394 0 : unsigned long storageClassIndex = SgOmpDepobjStatement::initializeStorageClassArray (SgOmpDepobjStatementStorageArray); ;
4395 0 : assert ( storageClassIndex == sizeOfActualPool );
4396 : }
4397 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDistributeStatement ) ;
4398 0 : std::cout << " SgOmpDistributeStatement has size " << sizeOfActualPool << std::endl;
4399 0 : SgOmpDistributeStatementStorageClass* SgOmpDistributeStatementStorageArray = NULL;
4400 0 : if ( 0 < sizeOfActualPool )
4401 : {
4402 0 : SgOmpDistributeStatementStorageArray = new SgOmpDistributeStatementStorageClass[sizeOfActualPool] ;
4403 0 : unsigned long storageClassIndex = SgOmpDistributeStatement::initializeStorageClassArray (SgOmpDistributeStatementStorageArray); ;
4404 0 : assert ( storageClassIndex == sizeOfActualPool );
4405 : }
4406 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpLoopStatement ) ;
4407 0 : std::cout << " SgOmpLoopStatement has size " << sizeOfActualPool << std::endl;
4408 0 : SgOmpLoopStatementStorageClass* SgOmpLoopStatementStorageArray = NULL;
4409 0 : if ( 0 < sizeOfActualPool )
4410 : {
4411 0 : SgOmpLoopStatementStorageArray = new SgOmpLoopStatementStorageClass[sizeOfActualPool] ;
4412 0 : unsigned long storageClassIndex = SgOmpLoopStatement::initializeStorageClassArray (SgOmpLoopStatementStorageArray); ;
4413 0 : assert ( storageClassIndex == sizeOfActualPool );
4414 : }
4415 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpScanStatement ) ;
4416 0 : std::cout << " SgOmpScanStatement has size " << sizeOfActualPool << std::endl;
4417 0 : SgOmpScanStatementStorageClass* SgOmpScanStatementStorageArray = NULL;
4418 0 : if ( 0 < sizeOfActualPool )
4419 : {
4420 0 : SgOmpScanStatementStorageArray = new SgOmpScanStatementStorageClass[sizeOfActualPool] ;
4421 0 : unsigned long storageClassIndex = SgOmpScanStatement::initializeStorageClassArray (SgOmpScanStatementStorageArray); ;
4422 0 : assert ( storageClassIndex == sizeOfActualPool );
4423 : }
4424 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskloopStatement ) ;
4425 0 : std::cout << " SgOmpTaskloopStatement has size " << sizeOfActualPool << std::endl;
4426 0 : SgOmpTaskloopStatementStorageClass* SgOmpTaskloopStatementStorageArray = NULL;
4427 0 : if ( 0 < sizeOfActualPool )
4428 : {
4429 0 : SgOmpTaskloopStatementStorageArray = new SgOmpTaskloopStatementStorageClass[sizeOfActualPool] ;
4430 0 : unsigned long storageClassIndex = SgOmpTaskloopStatement::initializeStorageClassArray (SgOmpTaskloopStatementStorageArray); ;
4431 0 : assert ( storageClassIndex == sizeOfActualPool );
4432 : }
4433 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetEnterDataStatement ) ;
4434 0 : std::cout << " SgOmpTargetEnterDataStatement has size " << sizeOfActualPool << std::endl;
4435 0 : SgOmpTargetEnterDataStatementStorageClass* SgOmpTargetEnterDataStatementStorageArray = NULL;
4436 0 : if ( 0 < sizeOfActualPool )
4437 : {
4438 0 : SgOmpTargetEnterDataStatementStorageArray = new SgOmpTargetEnterDataStatementStorageClass[sizeOfActualPool] ;
4439 0 : unsigned long storageClassIndex = SgOmpTargetEnterDataStatement::initializeStorageClassArray (SgOmpTargetEnterDataStatementStorageArray); ;
4440 0 : assert ( storageClassIndex == sizeOfActualPool );
4441 : }
4442 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetExitDataStatement ) ;
4443 0 : std::cout << " SgOmpTargetExitDataStatement has size " << sizeOfActualPool << std::endl;
4444 0 : SgOmpTargetExitDataStatementStorageClass* SgOmpTargetExitDataStatementStorageArray = NULL;
4445 0 : if ( 0 < sizeOfActualPool )
4446 : {
4447 0 : SgOmpTargetExitDataStatementStorageArray = new SgOmpTargetExitDataStatementStorageClass[sizeOfActualPool] ;
4448 0 : unsigned long storageClassIndex = SgOmpTargetExitDataStatement::initializeStorageClassArray (SgOmpTargetExitDataStatementStorageArray); ;
4449 0 : assert ( storageClassIndex == sizeOfActualPool );
4450 : }
4451 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSectionStatement ) ;
4452 0 : std::cout << " SgOmpSectionStatement has size " << sizeOfActualPool << std::endl;
4453 0 : SgOmpSectionStatementStorageClass* SgOmpSectionStatementStorageArray = NULL;
4454 0 : if ( 0 < sizeOfActualPool )
4455 : {
4456 0 : SgOmpSectionStatementStorageArray = new SgOmpSectionStatementStorageClass[sizeOfActualPool] ;
4457 0 : unsigned long storageClassIndex = SgOmpSectionStatement::initializeStorageClassArray (SgOmpSectionStatementStorageArray); ;
4458 0 : assert ( storageClassIndex == sizeOfActualPool );
4459 : }
4460 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSectionsStatement ) ;
4461 0 : std::cout << " SgOmpSectionsStatement has size " << sizeOfActualPool << std::endl;
4462 0 : SgOmpSectionsStatementStorageClass* SgOmpSectionsStatementStorageArray = NULL;
4463 0 : if ( 0 < sizeOfActualPool )
4464 : {
4465 0 : SgOmpSectionsStatementStorageArray = new SgOmpSectionsStatementStorageClass[sizeOfActualPool] ;
4466 0 : unsigned long storageClassIndex = SgOmpSectionsStatement::initializeStorageClassArray (SgOmpSectionsStatementStorageArray); ;
4467 0 : assert ( storageClassIndex == sizeOfActualPool );
4468 : }
4469 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSingleStatement ) ;
4470 0 : std::cout << " SgOmpSingleStatement has size " << sizeOfActualPool << std::endl;
4471 0 : SgOmpSingleStatementStorageClass* SgOmpSingleStatementStorageArray = NULL;
4472 0 : if ( 0 < sizeOfActualPool )
4473 : {
4474 0 : SgOmpSingleStatementStorageArray = new SgOmpSingleStatementStorageClass[sizeOfActualPool] ;
4475 0 : unsigned long storageClassIndex = SgOmpSingleStatement::initializeStorageClassArray (SgOmpSingleStatementStorageArray); ;
4476 0 : assert ( storageClassIndex == sizeOfActualPool );
4477 : }
4478 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskStatement ) ;
4479 0 : std::cout << " SgOmpTaskStatement has size " << sizeOfActualPool << std::endl;
4480 0 : SgOmpTaskStatementStorageClass* SgOmpTaskStatementStorageArray = NULL;
4481 0 : if ( 0 < sizeOfActualPool )
4482 : {
4483 0 : SgOmpTaskStatementStorageArray = new SgOmpTaskStatementStorageClass[sizeOfActualPool] ;
4484 0 : unsigned long storageClassIndex = SgOmpTaskStatement::initializeStorageClassArray (SgOmpTaskStatementStorageArray); ;
4485 0 : assert ( storageClassIndex == sizeOfActualPool );
4486 : }
4487 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskwaitStatement ) ;
4488 0 : std::cout << " SgOmpTaskwaitStatement has size " << sizeOfActualPool << std::endl;
4489 0 : SgOmpTaskwaitStatementStorageClass* SgOmpTaskwaitStatementStorageArray = NULL;
4490 0 : if ( 0 < sizeOfActualPool )
4491 : {
4492 0 : SgOmpTaskwaitStatementStorageArray = new SgOmpTaskwaitStatementStorageClass[sizeOfActualPool] ;
4493 0 : unsigned long storageClassIndex = SgOmpTaskwaitStatement::initializeStorageClassArray (SgOmpTaskwaitStatementStorageArray); ;
4494 0 : assert ( storageClassIndex == sizeOfActualPool );
4495 : }
4496 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpThreadprivateStatement ) ;
4497 0 : std::cout << " SgOmpThreadprivateStatement has size " << sizeOfActualPool << std::endl;
4498 0 : SgOmpThreadprivateStatementStorageClass* SgOmpThreadprivateStatementStorageArray = NULL;
4499 0 : if ( 0 < sizeOfActualPool )
4500 : {
4501 0 : SgOmpThreadprivateStatementStorageArray = new SgOmpThreadprivateStatementStorageClass[sizeOfActualPool] ;
4502 0 : unsigned long storageClassIndex = SgOmpThreadprivateStatement::initializeStorageClassArray (SgOmpThreadprivateStatementStorageArray); ;
4503 0 : assert ( storageClassIndex == sizeOfActualPool );
4504 : }
4505 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpWorkshareStatement ) ;
4506 0 : std::cout << " SgOmpWorkshareStatement has size " << sizeOfActualPool << std::endl;
4507 0 : SgOmpWorkshareStatementStorageClass* SgOmpWorkshareStatementStorageArray = NULL;
4508 0 : if ( 0 < sizeOfActualPool )
4509 : {
4510 0 : SgOmpWorkshareStatementStorageArray = new SgOmpWorkshareStatementStorageClass[sizeOfActualPool] ;
4511 0 : unsigned long storageClassIndex = SgOmpWorkshareStatement::initializeStorageClassArray (SgOmpWorkshareStatementStorageArray); ;
4512 0 : assert ( storageClassIndex == sizeOfActualPool );
4513 : }
4514 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirTaskStatement ) ;
4515 0 : std::cout << " SgUpirTaskStatement has size " << sizeOfActualPool << std::endl;
4516 0 : SgUpirTaskStatementStorageClass* SgUpirTaskStatementStorageArray = NULL;
4517 0 : if ( 0 < sizeOfActualPool )
4518 : {
4519 0 : SgUpirTaskStatementStorageArray = new SgUpirTaskStatementStorageClass[sizeOfActualPool] ;
4520 0 : unsigned long storageClassIndex = SgUpirTaskStatement::initializeStorageClassArray (SgUpirTaskStatementStorageArray); ;
4521 0 : assert ( storageClassIndex == sizeOfActualPool );
4522 : }
4523 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetDataStatement ) ;
4524 0 : std::cout << " SgOmpTargetDataStatement has size " << sizeOfActualPool << std::endl;
4525 0 : SgOmpTargetDataStatementStorageClass* SgOmpTargetDataStatementStorageArray = NULL;
4526 0 : if ( 0 < sizeOfActualPool )
4527 : {
4528 0 : SgOmpTargetDataStatementStorageArray = new SgOmpTargetDataStatementStorageClass[sizeOfActualPool] ;
4529 0 : unsigned long storageClassIndex = SgOmpTargetDataStatement::initializeStorageClassArray (SgOmpTargetDataStatementStorageArray); ;
4530 0 : assert ( storageClassIndex == sizeOfActualPool );
4531 : }
4532 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetParallelForStatement ) ;
4533 0 : std::cout << " SgOmpTargetParallelForStatement has size " << sizeOfActualPool << std::endl;
4534 0 : SgOmpTargetParallelForStatementStorageClass* SgOmpTargetParallelForStatementStorageArray = NULL;
4535 0 : if ( 0 < sizeOfActualPool )
4536 : {
4537 0 : SgOmpTargetParallelForStatementStorageArray = new SgOmpTargetParallelForStatementStorageClass[sizeOfActualPool] ;
4538 0 : unsigned long storageClassIndex = SgOmpTargetParallelForStatement::initializeStorageClassArray (SgOmpTargetParallelForStatementStorageArray); ;
4539 0 : assert ( storageClassIndex == sizeOfActualPool );
4540 : }
4541 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetUpdateStatement ) ;
4542 0 : std::cout << " SgOmpTargetUpdateStatement has size " << sizeOfActualPool << std::endl;
4543 0 : SgOmpTargetUpdateStatementStorageClass* SgOmpTargetUpdateStatementStorageArray = NULL;
4544 0 : if ( 0 < sizeOfActualPool )
4545 : {
4546 0 : SgOmpTargetUpdateStatementStorageArray = new SgOmpTargetUpdateStatementStorageClass[sizeOfActualPool] ;
4547 0 : unsigned long storageClassIndex = SgOmpTargetUpdateStatement::initializeStorageClassArray (SgOmpTargetUpdateStatementStorageArray); ;
4548 0 : assert ( storageClassIndex == sizeOfActualPool );
4549 : }
4550 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpRequiresStatement ) ;
4551 0 : std::cout << " SgOmpRequiresStatement has size " << sizeOfActualPool << std::endl;
4552 0 : SgOmpRequiresStatementStorageClass* SgOmpRequiresStatementStorageArray = NULL;
4553 0 : if ( 0 < sizeOfActualPool )
4554 : {
4555 0 : SgOmpRequiresStatementStorageArray = new SgOmpRequiresStatementStorageClass[sizeOfActualPool] ;
4556 0 : unsigned long storageClassIndex = SgOmpRequiresStatement::initializeStorageClassArray (SgOmpRequiresStatementStorageArray); ;
4557 0 : assert ( storageClassIndex == sizeOfActualPool );
4558 : }
4559 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetParallelStatement ) ;
4560 0 : std::cout << " SgOmpTargetParallelStatement has size " << sizeOfActualPool << std::endl;
4561 0 : SgOmpTargetParallelStatementStorageClass* SgOmpTargetParallelStatementStorageArray = NULL;
4562 0 : if ( 0 < sizeOfActualPool )
4563 : {
4564 0 : SgOmpTargetParallelStatementStorageArray = new SgOmpTargetParallelStatementStorageClass[sizeOfActualPool] ;
4565 0 : unsigned long storageClassIndex = SgOmpTargetParallelStatement::initializeStorageClassArray (SgOmpTargetParallelStatementStorageArray); ;
4566 0 : assert ( storageClassIndex == sizeOfActualPool );
4567 : }
4568 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetParallelForSimdStatement ) ;
4569 0 : std::cout << " SgOmpTargetParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
4570 0 : SgOmpTargetParallelForSimdStatementStorageClass* SgOmpTargetParallelForSimdStatementStorageArray = NULL;
4571 0 : if ( 0 < sizeOfActualPool )
4572 : {
4573 0 : SgOmpTargetParallelForSimdStatementStorageArray = new SgOmpTargetParallelForSimdStatementStorageClass[sizeOfActualPool] ;
4574 0 : unsigned long storageClassIndex = SgOmpTargetParallelForSimdStatement::initializeStorageClassArray (SgOmpTargetParallelForSimdStatementStorageArray); ;
4575 0 : assert ( storageClassIndex == sizeOfActualPool );
4576 : }
4577 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetParallelLoopStatement ) ;
4578 0 : std::cout << " SgOmpTargetParallelLoopStatement has size " << sizeOfActualPool << std::endl;
4579 0 : SgOmpTargetParallelLoopStatementStorageClass* SgOmpTargetParallelLoopStatementStorageArray = NULL;
4580 0 : if ( 0 < sizeOfActualPool )
4581 : {
4582 0 : SgOmpTargetParallelLoopStatementStorageArray = new SgOmpTargetParallelLoopStatementStorageClass[sizeOfActualPool] ;
4583 0 : unsigned long storageClassIndex = SgOmpTargetParallelLoopStatement::initializeStorageClassArray (SgOmpTargetParallelLoopStatementStorageArray); ;
4584 0 : assert ( storageClassIndex == sizeOfActualPool );
4585 : }
4586 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetSimdStatement ) ;
4587 0 : std::cout << " SgOmpTargetSimdStatement has size " << sizeOfActualPool << std::endl;
4588 0 : SgOmpTargetSimdStatementStorageClass* SgOmpTargetSimdStatementStorageArray = NULL;
4589 0 : if ( 0 < sizeOfActualPool )
4590 : {
4591 0 : SgOmpTargetSimdStatementStorageArray = new SgOmpTargetSimdStatementStorageClass[sizeOfActualPool] ;
4592 0 : unsigned long storageClassIndex = SgOmpTargetSimdStatement::initializeStorageClassArray (SgOmpTargetSimdStatementStorageArray); ;
4593 0 : assert ( storageClassIndex == sizeOfActualPool );
4594 : }
4595 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsStatement ) ;
4596 0 : std::cout << " SgOmpTargetTeamsStatement has size " << sizeOfActualPool << std::endl;
4597 0 : SgOmpTargetTeamsStatementStorageClass* SgOmpTargetTeamsStatementStorageArray = NULL;
4598 0 : if ( 0 < sizeOfActualPool )
4599 : {
4600 0 : SgOmpTargetTeamsStatementStorageArray = new SgOmpTargetTeamsStatementStorageClass[sizeOfActualPool] ;
4601 0 : unsigned long storageClassIndex = SgOmpTargetTeamsStatement::initializeStorageClassArray (SgOmpTargetTeamsStatementStorageArray); ;
4602 0 : assert ( storageClassIndex == sizeOfActualPool );
4603 : }
4604 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsDistributeStatement ) ;
4605 0 : std::cout << " SgOmpTargetTeamsDistributeStatement has size " << sizeOfActualPool << std::endl;
4606 0 : SgOmpTargetTeamsDistributeStatementStorageClass* SgOmpTargetTeamsDistributeStatementStorageArray = NULL;
4607 0 : if ( 0 < sizeOfActualPool )
4608 : {
4609 0 : SgOmpTargetTeamsDistributeStatementStorageArray = new SgOmpTargetTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
4610 0 : unsigned long storageClassIndex = SgOmpTargetTeamsDistributeStatement::initializeStorageClassArray (SgOmpTargetTeamsDistributeStatementStorageArray); ;
4611 0 : assert ( storageClassIndex == sizeOfActualPool );
4612 : }
4613 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsDistributeSimdStatement ) ;
4614 0 : std::cout << " SgOmpTargetTeamsDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
4615 0 : SgOmpTargetTeamsDistributeSimdStatementStorageClass* SgOmpTargetTeamsDistributeSimdStatementStorageArray = NULL;
4616 0 : if ( 0 < sizeOfActualPool )
4617 : {
4618 0 : SgOmpTargetTeamsDistributeSimdStatementStorageArray = new SgOmpTargetTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
4619 0 : unsigned long storageClassIndex = SgOmpTargetTeamsDistributeSimdStatement::initializeStorageClassArray (SgOmpTargetTeamsDistributeSimdStatementStorageArray); ;
4620 0 : assert ( storageClassIndex == sizeOfActualPool );
4621 : }
4622 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsLoopStatement ) ;
4623 0 : std::cout << " SgOmpTargetTeamsLoopStatement has size " << sizeOfActualPool << std::endl;
4624 0 : SgOmpTargetTeamsLoopStatementStorageClass* SgOmpTargetTeamsLoopStatementStorageArray = NULL;
4625 0 : if ( 0 < sizeOfActualPool )
4626 : {
4627 0 : SgOmpTargetTeamsLoopStatementStorageArray = new SgOmpTargetTeamsLoopStatementStorageClass[sizeOfActualPool] ;
4628 0 : unsigned long storageClassIndex = SgOmpTargetTeamsLoopStatement::initializeStorageClassArray (SgOmpTargetTeamsLoopStatementStorageArray); ;
4629 0 : assert ( storageClassIndex == sizeOfActualPool );
4630 : }
4631 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsDistributeParallelForStatement ) ;
4632 0 : std::cout << " SgOmpTargetTeamsDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
4633 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass* SgOmpTargetTeamsDistributeParallelForStatementStorageArray = NULL;
4634 0 : if ( 0 < sizeOfActualPool )
4635 : {
4636 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageArray = new SgOmpTargetTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
4637 0 : unsigned long storageClassIndex = SgOmpTargetTeamsDistributeParallelForStatement::initializeStorageClassArray (SgOmpTargetTeamsDistributeParallelForStatementStorageArray); ;
4638 0 : assert ( storageClassIndex == sizeOfActualPool );
4639 : }
4640 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTargetTeamsDistributeParallelForSimdStatement ) ;
4641 0 : std::cout << " SgOmpTargetTeamsDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
4642 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass* SgOmpTargetTeamsDistributeParallelForSimdStatementStorageArray = NULL;
4643 0 : if ( 0 < sizeOfActualPool )
4644 : {
4645 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageArray = new SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
4646 0 : unsigned long storageClassIndex = SgOmpTargetTeamsDistributeParallelForSimdStatement::initializeStorageClassArray (SgOmpTargetTeamsDistributeParallelForSimdStatementStorageArray); ;
4647 0 : assert ( storageClassIndex == sizeOfActualPool );
4648 : }
4649 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDistributeSimdStatement ) ;
4650 0 : std::cout << " SgOmpDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
4651 0 : SgOmpDistributeSimdStatementStorageClass* SgOmpDistributeSimdStatementStorageArray = NULL;
4652 0 : if ( 0 < sizeOfActualPool )
4653 : {
4654 0 : SgOmpDistributeSimdStatementStorageArray = new SgOmpDistributeSimdStatementStorageClass[sizeOfActualPool] ;
4655 0 : unsigned long storageClassIndex = SgOmpDistributeSimdStatement::initializeStorageClassArray (SgOmpDistributeSimdStatementStorageArray); ;
4656 0 : assert ( storageClassIndex == sizeOfActualPool );
4657 : }
4658 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDistributeParallelForStatement ) ;
4659 0 : std::cout << " SgOmpDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
4660 0 : SgOmpDistributeParallelForStatementStorageClass* SgOmpDistributeParallelForStatementStorageArray = NULL;
4661 0 : if ( 0 < sizeOfActualPool )
4662 : {
4663 0 : SgOmpDistributeParallelForStatementStorageArray = new SgOmpDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
4664 0 : unsigned long storageClassIndex = SgOmpDistributeParallelForStatement::initializeStorageClassArray (SgOmpDistributeParallelForStatementStorageArray); ;
4665 0 : assert ( storageClassIndex == sizeOfActualPool );
4666 : }
4667 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDistributeParallelForSimdStatement ) ;
4668 0 : std::cout << " SgOmpDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
4669 0 : SgOmpDistributeParallelForSimdStatementStorageClass* SgOmpDistributeParallelForSimdStatementStorageArray = NULL;
4670 0 : if ( 0 < sizeOfActualPool )
4671 : {
4672 0 : SgOmpDistributeParallelForSimdStatementStorageArray = new SgOmpDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
4673 0 : unsigned long storageClassIndex = SgOmpDistributeParallelForSimdStatement::initializeStorageClassArray (SgOmpDistributeParallelForSimdStatementStorageArray); ;
4674 0 : assert ( storageClassIndex == sizeOfActualPool );
4675 : }
4676 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskloopSimdStatement ) ;
4677 0 : std::cout << " SgOmpTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
4678 0 : SgOmpTaskloopSimdStatementStorageClass* SgOmpTaskloopSimdStatementStorageArray = NULL;
4679 0 : if ( 0 < sizeOfActualPool )
4680 : {
4681 0 : SgOmpTaskloopSimdStatementStorageArray = new SgOmpTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
4682 0 : unsigned long storageClassIndex = SgOmpTaskloopSimdStatement::initializeStorageClassArray (SgOmpTaskloopSimdStatementStorageArray); ;
4683 0 : assert ( storageClassIndex == sizeOfActualPool );
4684 : }
4685 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMasterTaskloopSimdStatement ) ;
4686 0 : std::cout << " SgOmpMasterTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
4687 0 : SgOmpMasterTaskloopSimdStatementStorageClass* SgOmpMasterTaskloopSimdStatementStorageArray = NULL;
4688 0 : if ( 0 < sizeOfActualPool )
4689 : {
4690 0 : SgOmpMasterTaskloopSimdStatementStorageArray = new SgOmpMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
4691 0 : unsigned long storageClassIndex = SgOmpMasterTaskloopSimdStatement::initializeStorageClassArray (SgOmpMasterTaskloopSimdStatementStorageArray); ;
4692 0 : assert ( storageClassIndex == sizeOfActualPool );
4693 : }
4694 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpParallelMasterTaskloopStatement ) ;
4695 0 : std::cout << " SgOmpParallelMasterTaskloopStatement has size " << sizeOfActualPool << std::endl;
4696 0 : SgOmpParallelMasterTaskloopStatementStorageClass* SgOmpParallelMasterTaskloopStatementStorageArray = NULL;
4697 0 : if ( 0 < sizeOfActualPool )
4698 : {
4699 0 : SgOmpParallelMasterTaskloopStatementStorageArray = new SgOmpParallelMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
4700 0 : unsigned long storageClassIndex = SgOmpParallelMasterTaskloopStatement::initializeStorageClassArray (SgOmpParallelMasterTaskloopStatementStorageArray); ;
4701 0 : assert ( storageClassIndex == sizeOfActualPool );
4702 : }
4703 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpParallelMasterTaskloopSimdStatement ) ;
4704 0 : std::cout << " SgOmpParallelMasterTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
4705 0 : SgOmpParallelMasterTaskloopSimdStatementStorageClass* SgOmpParallelMasterTaskloopSimdStatementStorageArray = NULL;
4706 0 : if ( 0 < sizeOfActualPool )
4707 : {
4708 0 : SgOmpParallelMasterTaskloopSimdStatementStorageArray = new SgOmpParallelMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
4709 0 : unsigned long storageClassIndex = SgOmpParallelMasterTaskloopSimdStatement::initializeStorageClassArray (SgOmpParallelMasterTaskloopSimdStatementStorageArray); ;
4710 0 : assert ( storageClassIndex == sizeOfActualPool );
4711 : }
4712 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsDistributeStatement ) ;
4713 0 : std::cout << " SgOmpTeamsDistributeStatement has size " << sizeOfActualPool << std::endl;
4714 0 : SgOmpTeamsDistributeStatementStorageClass* SgOmpTeamsDistributeStatementStorageArray = NULL;
4715 0 : if ( 0 < sizeOfActualPool )
4716 : {
4717 0 : SgOmpTeamsDistributeStatementStorageArray = new SgOmpTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
4718 0 : unsigned long storageClassIndex = SgOmpTeamsDistributeStatement::initializeStorageClassArray (SgOmpTeamsDistributeStatementStorageArray); ;
4719 0 : assert ( storageClassIndex == sizeOfActualPool );
4720 : }
4721 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsDistributeSimdStatement ) ;
4722 0 : std::cout << " SgOmpTeamsDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
4723 0 : SgOmpTeamsDistributeSimdStatementStorageClass* SgOmpTeamsDistributeSimdStatementStorageArray = NULL;
4724 0 : if ( 0 < sizeOfActualPool )
4725 : {
4726 0 : SgOmpTeamsDistributeSimdStatementStorageArray = new SgOmpTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
4727 0 : unsigned long storageClassIndex = SgOmpTeamsDistributeSimdStatement::initializeStorageClassArray (SgOmpTeamsDistributeSimdStatementStorageArray); ;
4728 0 : assert ( storageClassIndex == sizeOfActualPool );
4729 : }
4730 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsDistributeParallelForStatement ) ;
4731 0 : std::cout << " SgOmpTeamsDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
4732 0 : SgOmpTeamsDistributeParallelForStatementStorageClass* SgOmpTeamsDistributeParallelForStatementStorageArray = NULL;
4733 0 : if ( 0 < sizeOfActualPool )
4734 : {
4735 0 : SgOmpTeamsDistributeParallelForStatementStorageArray = new SgOmpTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
4736 0 : unsigned long storageClassIndex = SgOmpTeamsDistributeParallelForStatement::initializeStorageClassArray (SgOmpTeamsDistributeParallelForStatementStorageArray); ;
4737 0 : assert ( storageClassIndex == sizeOfActualPool );
4738 : }
4739 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsDistributeParallelForSimdStatement ) ;
4740 0 : std::cout << " SgOmpTeamsDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
4741 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass* SgOmpTeamsDistributeParallelForSimdStatementStorageArray = NULL;
4742 0 : if ( 0 < sizeOfActualPool )
4743 : {
4744 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageArray = new SgOmpTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
4745 0 : unsigned long storageClassIndex = SgOmpTeamsDistributeParallelForSimdStatement::initializeStorageClassArray (SgOmpTeamsDistributeParallelForSimdStatementStorageArray); ;
4746 0 : assert ( storageClassIndex == sizeOfActualPool );
4747 : }
4748 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTeamsLoopStatement ) ;
4749 0 : std::cout << " SgOmpTeamsLoopStatement has size " << sizeOfActualPool << std::endl;
4750 0 : SgOmpTeamsLoopStatementStorageClass* SgOmpTeamsLoopStatementStorageArray = NULL;
4751 0 : if ( 0 < sizeOfActualPool )
4752 : {
4753 0 : SgOmpTeamsLoopStatementStorageArray = new SgOmpTeamsLoopStatementStorageClass[sizeOfActualPool] ;
4754 0 : unsigned long storageClassIndex = SgOmpTeamsLoopStatement::initializeStorageClassArray (SgOmpTeamsLoopStatementStorageArray); ;
4755 0 : assert ( storageClassIndex == sizeOfActualPool );
4756 : }
4757 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpParallelLoopStatement ) ;
4758 0 : std::cout << " SgOmpParallelLoopStatement has size " << sizeOfActualPool << std::endl;
4759 0 : SgOmpParallelLoopStatementStorageClass* SgOmpParallelLoopStatementStorageArray = NULL;
4760 0 : if ( 0 < sizeOfActualPool )
4761 : {
4762 0 : SgOmpParallelLoopStatementStorageArray = new SgOmpParallelLoopStatementStorageClass[sizeOfActualPool] ;
4763 0 : unsigned long storageClassIndex = SgOmpParallelLoopStatement::initializeStorageClassArray (SgOmpParallelLoopStatementStorageArray); ;
4764 0 : assert ( storageClassIndex == sizeOfActualPool );
4765 : }
4766 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpParallelMasterStatement ) ;
4767 0 : std::cout << " SgOmpParallelMasterStatement has size " << sizeOfActualPool << std::endl;
4768 0 : SgOmpParallelMasterStatementStorageClass* SgOmpParallelMasterStatementStorageArray = NULL;
4769 0 : if ( 0 < sizeOfActualPool )
4770 : {
4771 0 : SgOmpParallelMasterStatementStorageArray = new SgOmpParallelMasterStatementStorageClass[sizeOfActualPool] ;
4772 0 : unsigned long storageClassIndex = SgOmpParallelMasterStatement::initializeStorageClassArray (SgOmpParallelMasterStatementStorageArray); ;
4773 0 : assert ( storageClassIndex == sizeOfActualPool );
4774 : }
4775 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMasterTaskloopStatement ) ;
4776 0 : std::cout << " SgOmpMasterTaskloopStatement has size " << sizeOfActualPool << std::endl;
4777 0 : SgOmpMasterTaskloopStatementStorageClass* SgOmpMasterTaskloopStatementStorageArray = NULL;
4778 0 : if ( 0 < sizeOfActualPool )
4779 : {
4780 0 : SgOmpMasterTaskloopStatementStorageArray = new SgOmpMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
4781 0 : unsigned long storageClassIndex = SgOmpMasterTaskloopStatement::initializeStorageClassArray (SgOmpMasterTaskloopStatementStorageArray); ;
4782 0 : assert ( storageClassIndex == sizeOfActualPool );
4783 : }
4784 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUnrollStatement ) ;
4785 0 : std::cout << " SgOmpUnrollStatement has size " << sizeOfActualPool << std::endl;
4786 0 : SgOmpUnrollStatementStorageClass* SgOmpUnrollStatementStorageArray = NULL;
4787 0 : if ( 0 < sizeOfActualPool )
4788 : {
4789 0 : SgOmpUnrollStatementStorageArray = new SgOmpUnrollStatementStorageClass[sizeOfActualPool] ;
4790 0 : unsigned long storageClassIndex = SgOmpUnrollStatement::initializeStorageClassArray (SgOmpUnrollStatementStorageArray); ;
4791 0 : assert ( storageClassIndex == sizeOfActualPool );
4792 : }
4793 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTileStatement ) ;
4794 0 : std::cout << " SgOmpTileStatement has size " << sizeOfActualPool << std::endl;
4795 0 : SgOmpTileStatementStorageClass* SgOmpTileStatementStorageArray = NULL;
4796 0 : if ( 0 < sizeOfActualPool )
4797 : {
4798 0 : SgOmpTileStatementStorageArray = new SgOmpTileStatementStorageClass[sizeOfActualPool] ;
4799 0 : unsigned long storageClassIndex = SgOmpTileStatement::initializeStorageClassArray (SgOmpTileStatementStorageArray); ;
4800 0 : assert ( storageClassIndex == sizeOfActualPool );
4801 : }
4802 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirSimdStatement ) ;
4803 0 : std::cout << " SgUpirSimdStatement has size " << sizeOfActualPool << std::endl;
4804 0 : SgUpirSimdStatementStorageClass* SgUpirSimdStatementStorageArray = NULL;
4805 0 : if ( 0 < sizeOfActualPool )
4806 : {
4807 0 : SgUpirSimdStatementStorageArray = new SgUpirSimdStatementStorageClass[sizeOfActualPool] ;
4808 0 : unsigned long storageClassIndex = SgUpirSimdStatement::initializeStorageClassArray (SgUpirSimdStatementStorageArray); ;
4809 0 : assert ( storageClassIndex == sizeOfActualPool );
4810 : }
4811 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirBaseStatement ) ;
4812 0 : std::cout << " SgUpirBaseStatement has size " << sizeOfActualPool << std::endl;
4813 0 : SgUpirBaseStatementStorageClass* SgUpirBaseStatementStorageArray = NULL;
4814 0 : if ( 0 < sizeOfActualPool )
4815 : {
4816 0 : SgUpirBaseStatementStorageArray = new SgUpirBaseStatementStorageClass[sizeOfActualPool] ;
4817 0 : unsigned long storageClassIndex = SgUpirBaseStatement::initializeStorageClassArray (SgUpirBaseStatementStorageArray); ;
4818 0 : assert ( storageClassIndex == sizeOfActualPool );
4819 : }
4820 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirLoopStatement ) ;
4821 0 : std::cout << " SgUpirLoopStatement has size " << sizeOfActualPool << std::endl;
4822 0 : SgUpirLoopStatementStorageClass* SgUpirLoopStatementStorageArray = NULL;
4823 0 : if ( 0 < sizeOfActualPool )
4824 : {
4825 0 : SgUpirLoopStatementStorageArray = new SgUpirLoopStatementStorageClass[sizeOfActualPool] ;
4826 0 : unsigned long storageClassIndex = SgUpirLoopStatement::initializeStorageClassArray (SgUpirLoopStatementStorageArray); ;
4827 0 : assert ( storageClassIndex == sizeOfActualPool );
4828 : }
4829 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirLoopParallelStatement ) ;
4830 0 : std::cout << " SgUpirLoopParallelStatement has size " << sizeOfActualPool << std::endl;
4831 0 : SgUpirLoopParallelStatementStorageClass* SgUpirLoopParallelStatementStorageArray = NULL;
4832 0 : if ( 0 < sizeOfActualPool )
4833 : {
4834 0 : SgUpirLoopParallelStatementStorageArray = new SgUpirLoopParallelStatementStorageClass[sizeOfActualPool] ;
4835 0 : unsigned long storageClassIndex = SgUpirLoopParallelStatement::initializeStorageClassArray (SgUpirLoopParallelStatementStorageArray); ;
4836 0 : assert ( storageClassIndex == sizeOfActualPool );
4837 : }
4838 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirSyncStatement ) ;
4839 0 : std::cout << " SgUpirSyncStatement has size " << sizeOfActualPool << std::endl;
4840 0 : SgUpirSyncStatementStorageClass* SgUpirSyncStatementStorageArray = NULL;
4841 0 : if ( 0 < sizeOfActualPool )
4842 : {
4843 0 : SgUpirSyncStatementStorageArray = new SgUpirSyncStatementStorageClass[sizeOfActualPool] ;
4844 0 : unsigned long storageClassIndex = SgUpirSyncStatement::initializeStorageClassArray (SgUpirSyncStatementStorageArray); ;
4845 0 : assert ( storageClassIndex == sizeOfActualPool );
4846 : }
4847 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpClause ) ;
4848 0 : std::cout << " SgOmpClause has size " << sizeOfActualPool << std::endl;
4849 0 : SgOmpClauseStorageClass* SgOmpClauseStorageArray = NULL;
4850 0 : if ( 0 < sizeOfActualPool )
4851 : {
4852 0 : SgOmpClauseStorageArray = new SgOmpClauseStorageClass[sizeOfActualPool] ;
4853 0 : unsigned long storageClassIndex = SgOmpClause::initializeStorageClassArray (SgOmpClauseStorageArray); ;
4854 0 : assert ( storageClassIndex == sizeOfActualPool );
4855 : }
4856 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAllocateClause ) ;
4857 0 : std::cout << " SgOmpAllocateClause has size " << sizeOfActualPool << std::endl;
4858 0 : SgOmpAllocateClauseStorageClass* SgOmpAllocateClauseStorageArray = NULL;
4859 0 : if ( 0 < sizeOfActualPool )
4860 : {
4861 0 : SgOmpAllocateClauseStorageArray = new SgOmpAllocateClauseStorageClass[sizeOfActualPool] ;
4862 0 : unsigned long storageClassIndex = SgOmpAllocateClause::initializeStorageClassArray (SgOmpAllocateClauseStorageArray); ;
4863 0 : assert ( storageClassIndex == sizeOfActualPool );
4864 : }
4865 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAllocatorClause ) ;
4866 0 : std::cout << " SgOmpAllocatorClause has size " << sizeOfActualPool << std::endl;
4867 0 : SgOmpAllocatorClauseStorageClass* SgOmpAllocatorClauseStorageArray = NULL;
4868 0 : if ( 0 < sizeOfActualPool )
4869 : {
4870 0 : SgOmpAllocatorClauseStorageArray = new SgOmpAllocatorClauseStorageClass[sizeOfActualPool] ;
4871 0 : unsigned long storageClassIndex = SgOmpAllocatorClause::initializeStorageClassArray (SgOmpAllocatorClauseStorageArray); ;
4872 0 : assert ( storageClassIndex == sizeOfActualPool );
4873 : }
4874 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUsesAllocatorsClause ) ;
4875 0 : std::cout << " SgOmpUsesAllocatorsClause has size " << sizeOfActualPool << std::endl;
4876 0 : SgOmpUsesAllocatorsClauseStorageClass* SgOmpUsesAllocatorsClauseStorageArray = NULL;
4877 0 : if ( 0 < sizeOfActualPool )
4878 : {
4879 0 : SgOmpUsesAllocatorsClauseStorageArray = new SgOmpUsesAllocatorsClauseStorageClass[sizeOfActualPool] ;
4880 0 : unsigned long storageClassIndex = SgOmpUsesAllocatorsClause::initializeStorageClassArray (SgOmpUsesAllocatorsClauseStorageArray); ;
4881 0 : assert ( storageClassIndex == sizeOfActualPool );
4882 : }
4883 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUsesAllocatorsDefination ) ;
4884 0 : std::cout << " SgOmpUsesAllocatorsDefination has size " << sizeOfActualPool << std::endl;
4885 0 : SgOmpUsesAllocatorsDefinationStorageClass* SgOmpUsesAllocatorsDefinationStorageArray = NULL;
4886 0 : if ( 0 < sizeOfActualPool )
4887 : {
4888 0 : SgOmpUsesAllocatorsDefinationStorageArray = new SgOmpUsesAllocatorsDefinationStorageClass[sizeOfActualPool] ;
4889 0 : unsigned long storageClassIndex = SgOmpUsesAllocatorsDefination::initializeStorageClassArray (SgOmpUsesAllocatorsDefinationStorageArray); ;
4890 0 : assert ( storageClassIndex == sizeOfActualPool );
4891 : }
4892 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpToClause ) ;
4893 0 : std::cout << " SgOmpToClause has size " << sizeOfActualPool << std::endl;
4894 0 : SgOmpToClauseStorageClass* SgOmpToClauseStorageArray = NULL;
4895 0 : if ( 0 < sizeOfActualPool )
4896 : {
4897 0 : SgOmpToClauseStorageArray = new SgOmpToClauseStorageClass[sizeOfActualPool] ;
4898 0 : unsigned long storageClassIndex = SgOmpToClause::initializeStorageClassArray (SgOmpToClauseStorageArray); ;
4899 0 : assert ( storageClassIndex == sizeOfActualPool );
4900 : }
4901 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpFromClause ) ;
4902 0 : std::cout << " SgOmpFromClause has size " << sizeOfActualPool << std::endl;
4903 0 : SgOmpFromClauseStorageClass* SgOmpFromClauseStorageArray = NULL;
4904 0 : if ( 0 < sizeOfActualPool )
4905 : {
4906 0 : SgOmpFromClauseStorageArray = new SgOmpFromClauseStorageClass[sizeOfActualPool] ;
4907 0 : unsigned long storageClassIndex = SgOmpFromClause::initializeStorageClassArray (SgOmpFromClauseStorageArray); ;
4908 0 : assert ( storageClassIndex == sizeOfActualPool );
4909 : }
4910 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpThreadsClause ) ;
4911 0 : std::cout << " SgOmpThreadsClause has size " << sizeOfActualPool << std::endl;
4912 0 : SgOmpThreadsClauseStorageClass* SgOmpThreadsClauseStorageArray = NULL;
4913 0 : if ( 0 < sizeOfActualPool )
4914 : {
4915 0 : SgOmpThreadsClauseStorageArray = new SgOmpThreadsClauseStorageClass[sizeOfActualPool] ;
4916 0 : unsigned long storageClassIndex = SgOmpThreadsClause::initializeStorageClassArray (SgOmpThreadsClauseStorageArray); ;
4917 0 : assert ( storageClassIndex == sizeOfActualPool );
4918 : }
4919 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSimdClause ) ;
4920 0 : std::cout << " SgOmpSimdClause has size " << sizeOfActualPool << std::endl;
4921 0 : SgOmpSimdClauseStorageClass* SgOmpSimdClauseStorageArray = NULL;
4922 0 : if ( 0 < sizeOfActualPool )
4923 : {
4924 0 : SgOmpSimdClauseStorageArray = new SgOmpSimdClauseStorageClass[sizeOfActualPool] ;
4925 0 : unsigned long storageClassIndex = SgOmpSimdClause::initializeStorageClassArray (SgOmpSimdClauseStorageArray); ;
4926 0 : assert ( storageClassIndex == sizeOfActualPool );
4927 : }
4928 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpBeginClause ) ;
4929 0 : std::cout << " SgOmpBeginClause has size " << sizeOfActualPool << std::endl;
4930 0 : SgOmpBeginClauseStorageClass* SgOmpBeginClauseStorageArray = NULL;
4931 0 : if ( 0 < sizeOfActualPool )
4932 : {
4933 0 : SgOmpBeginClauseStorageArray = new SgOmpBeginClauseStorageClass[sizeOfActualPool] ;
4934 0 : unsigned long storageClassIndex = SgOmpBeginClause::initializeStorageClassArray (SgOmpBeginClauseStorageArray); ;
4935 0 : assert ( storageClassIndex == sizeOfActualPool );
4936 : }
4937 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCollapseClause ) ;
4938 0 : std::cout << " SgOmpCollapseClause has size " << sizeOfActualPool << std::endl;
4939 0 : SgOmpCollapseClauseStorageClass* SgOmpCollapseClauseStorageArray = NULL;
4940 0 : if ( 0 < sizeOfActualPool )
4941 : {
4942 0 : SgOmpCollapseClauseStorageArray = new SgOmpCollapseClauseStorageClass[sizeOfActualPool] ;
4943 0 : unsigned long storageClassIndex = SgOmpCollapseClause::initializeStorageClassArray (SgOmpCollapseClauseStorageArray); ;
4944 0 : assert ( storageClassIndex == sizeOfActualPool );
4945 : }
4946 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCopyinClause ) ;
4947 0 : std::cout << " SgOmpCopyinClause has size " << sizeOfActualPool << std::endl;
4948 0 : SgOmpCopyinClauseStorageClass* SgOmpCopyinClauseStorageArray = NULL;
4949 0 : if ( 0 < sizeOfActualPool )
4950 : {
4951 0 : SgOmpCopyinClauseStorageArray = new SgOmpCopyinClauseStorageClass[sizeOfActualPool] ;
4952 0 : unsigned long storageClassIndex = SgOmpCopyinClause::initializeStorageClassArray (SgOmpCopyinClauseStorageArray); ;
4953 0 : assert ( storageClassIndex == sizeOfActualPool );
4954 : }
4955 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCopyprivateClause ) ;
4956 0 : std::cout << " SgOmpCopyprivateClause has size " << sizeOfActualPool << std::endl;
4957 0 : SgOmpCopyprivateClauseStorageClass* SgOmpCopyprivateClauseStorageArray = NULL;
4958 0 : if ( 0 < sizeOfActualPool )
4959 : {
4960 0 : SgOmpCopyprivateClauseStorageArray = new SgOmpCopyprivateClauseStorageClass[sizeOfActualPool] ;
4961 0 : unsigned long storageClassIndex = SgOmpCopyprivateClause::initializeStorageClassArray (SgOmpCopyprivateClauseStorageArray); ;
4962 0 : assert ( storageClassIndex == sizeOfActualPool );
4963 : }
4964 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDefaultClause ) ;
4965 0 : std::cout << " SgOmpDefaultClause has size " << sizeOfActualPool << std::endl;
4966 0 : SgOmpDefaultClauseStorageClass* SgOmpDefaultClauseStorageArray = NULL;
4967 0 : if ( 0 < sizeOfActualPool )
4968 : {
4969 0 : SgOmpDefaultClauseStorageArray = new SgOmpDefaultClauseStorageClass[sizeOfActualPool] ;
4970 0 : unsigned long storageClassIndex = SgOmpDefaultClause::initializeStorageClassArray (SgOmpDefaultClauseStorageArray); ;
4971 0 : assert ( storageClassIndex == sizeOfActualPool );
4972 : }
4973 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpEndClause ) ;
4974 0 : std::cout << " SgOmpEndClause has size " << sizeOfActualPool << std::endl;
4975 0 : SgOmpEndClauseStorageClass* SgOmpEndClauseStorageArray = NULL;
4976 0 : if ( 0 < sizeOfActualPool )
4977 : {
4978 0 : SgOmpEndClauseStorageArray = new SgOmpEndClauseStorageClass[sizeOfActualPool] ;
4979 0 : unsigned long storageClassIndex = SgOmpEndClause::initializeStorageClassArray (SgOmpEndClauseStorageArray); ;
4980 0 : assert ( storageClassIndex == sizeOfActualPool );
4981 : }
4982 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpExpressionClause ) ;
4983 0 : std::cout << " SgOmpExpressionClause has size " << sizeOfActualPool << std::endl;
4984 0 : SgOmpExpressionClauseStorageClass* SgOmpExpressionClauseStorageArray = NULL;
4985 0 : if ( 0 < sizeOfActualPool )
4986 : {
4987 0 : SgOmpExpressionClauseStorageArray = new SgOmpExpressionClauseStorageClass[sizeOfActualPool] ;
4988 0 : unsigned long storageClassIndex = SgOmpExpressionClause::initializeStorageClassArray (SgOmpExpressionClauseStorageArray); ;
4989 0 : assert ( storageClassIndex == sizeOfActualPool );
4990 : }
4991 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpFirstprivateClause ) ;
4992 0 : std::cout << " SgOmpFirstprivateClause has size " << sizeOfActualPool << std::endl;
4993 0 : SgOmpFirstprivateClauseStorageClass* SgOmpFirstprivateClauseStorageArray = NULL;
4994 0 : if ( 0 < sizeOfActualPool )
4995 : {
4996 0 : SgOmpFirstprivateClauseStorageArray = new SgOmpFirstprivateClauseStorageClass[sizeOfActualPool] ;
4997 0 : unsigned long storageClassIndex = SgOmpFirstprivateClause::initializeStorageClassArray (SgOmpFirstprivateClauseStorageArray); ;
4998 0 : assert ( storageClassIndex == sizeOfActualPool );
4999 : }
5000 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpIfClause ) ;
5001 0 : std::cout << " SgOmpIfClause has size " << sizeOfActualPool << std::endl;
5002 0 : SgOmpIfClauseStorageClass* SgOmpIfClauseStorageArray = NULL;
5003 0 : if ( 0 < sizeOfActualPool )
5004 : {
5005 0 : SgOmpIfClauseStorageArray = new SgOmpIfClauseStorageClass[sizeOfActualPool] ;
5006 0 : unsigned long storageClassIndex = SgOmpIfClause::initializeStorageClassArray (SgOmpIfClauseStorageArray); ;
5007 0 : assert ( storageClassIndex == sizeOfActualPool );
5008 : }
5009 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpFinalClause ) ;
5010 0 : std::cout << " SgOmpFinalClause has size " << sizeOfActualPool << std::endl;
5011 0 : SgOmpFinalClauseStorageClass* SgOmpFinalClauseStorageArray = NULL;
5012 0 : if ( 0 < sizeOfActualPool )
5013 : {
5014 0 : SgOmpFinalClauseStorageArray = new SgOmpFinalClauseStorageClass[sizeOfActualPool] ;
5015 0 : unsigned long storageClassIndex = SgOmpFinalClause::initializeStorageClassArray (SgOmpFinalClauseStorageArray); ;
5016 0 : assert ( storageClassIndex == sizeOfActualPool );
5017 : }
5018 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpPriorityClause ) ;
5019 0 : std::cout << " SgOmpPriorityClause has size " << sizeOfActualPool << std::endl;
5020 0 : SgOmpPriorityClauseStorageClass* SgOmpPriorityClauseStorageArray = NULL;
5021 0 : if ( 0 < sizeOfActualPool )
5022 : {
5023 0 : SgOmpPriorityClauseStorageArray = new SgOmpPriorityClauseStorageClass[sizeOfActualPool] ;
5024 0 : unsigned long storageClassIndex = SgOmpPriorityClause::initializeStorageClassArray (SgOmpPriorityClauseStorageArray); ;
5025 0 : assert ( storageClassIndex == sizeOfActualPool );
5026 : }
5027 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDeviceClause ) ;
5028 0 : std::cout << " SgOmpDeviceClause has size " << sizeOfActualPool << std::endl;
5029 0 : SgOmpDeviceClauseStorageClass* SgOmpDeviceClauseStorageArray = NULL;
5030 0 : if ( 0 < sizeOfActualPool )
5031 : {
5032 0 : SgOmpDeviceClauseStorageArray = new SgOmpDeviceClauseStorageClass[sizeOfActualPool] ;
5033 0 : unsigned long storageClassIndex = SgOmpDeviceClause::initializeStorageClassArray (SgOmpDeviceClauseStorageArray); ;
5034 0 : assert ( storageClassIndex == sizeOfActualPool );
5035 : }
5036 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpLastprivateClause ) ;
5037 0 : std::cout << " SgOmpLastprivateClause has size " << sizeOfActualPool << std::endl;
5038 0 : SgOmpLastprivateClauseStorageClass* SgOmpLastprivateClauseStorageArray = NULL;
5039 0 : if ( 0 < sizeOfActualPool )
5040 : {
5041 0 : SgOmpLastprivateClauseStorageArray = new SgOmpLastprivateClauseStorageClass[sizeOfActualPool] ;
5042 0 : unsigned long storageClassIndex = SgOmpLastprivateClause::initializeStorageClassArray (SgOmpLastprivateClauseStorageArray); ;
5043 0 : assert ( storageClassIndex == sizeOfActualPool );
5044 : }
5045 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNowaitClause ) ;
5046 0 : std::cout << " SgOmpNowaitClause has size " << sizeOfActualPool << std::endl;
5047 0 : SgOmpNowaitClauseStorageClass* SgOmpNowaitClauseStorageArray = NULL;
5048 0 : if ( 0 < sizeOfActualPool )
5049 : {
5050 0 : SgOmpNowaitClauseStorageArray = new SgOmpNowaitClauseStorageClass[sizeOfActualPool] ;
5051 0 : unsigned long storageClassIndex = SgOmpNowaitClause::initializeStorageClassArray (SgOmpNowaitClauseStorageArray); ;
5052 0 : assert ( storageClassIndex == sizeOfActualPool );
5053 : }
5054 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpReadClause ) ;
5055 0 : std::cout << " SgOmpReadClause has size " << sizeOfActualPool << std::endl;
5056 0 : SgOmpReadClauseStorageClass* SgOmpReadClauseStorageArray = NULL;
5057 0 : if ( 0 < sizeOfActualPool )
5058 : {
5059 0 : SgOmpReadClauseStorageArray = new SgOmpReadClauseStorageClass[sizeOfActualPool] ;
5060 0 : unsigned long storageClassIndex = SgOmpReadClause::initializeStorageClassArray (SgOmpReadClauseStorageArray); ;
5061 0 : assert ( storageClassIndex == sizeOfActualPool );
5062 : }
5063 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpWriteClause ) ;
5064 0 : std::cout << " SgOmpWriteClause has size " << sizeOfActualPool << std::endl;
5065 0 : SgOmpWriteClauseStorageClass* SgOmpWriteClauseStorageArray = NULL;
5066 0 : if ( 0 < sizeOfActualPool )
5067 : {
5068 0 : SgOmpWriteClauseStorageArray = new SgOmpWriteClauseStorageClass[sizeOfActualPool] ;
5069 0 : unsigned long storageClassIndex = SgOmpWriteClause::initializeStorageClassArray (SgOmpWriteClauseStorageArray); ;
5070 0 : assert ( storageClassIndex == sizeOfActualPool );
5071 : }
5072 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUpdateClause ) ;
5073 0 : std::cout << " SgOmpUpdateClause has size " << sizeOfActualPool << std::endl;
5074 0 : SgOmpUpdateClauseStorageClass* SgOmpUpdateClauseStorageArray = NULL;
5075 0 : if ( 0 < sizeOfActualPool )
5076 : {
5077 0 : SgOmpUpdateClauseStorageArray = new SgOmpUpdateClauseStorageClass[sizeOfActualPool] ;
5078 0 : unsigned long storageClassIndex = SgOmpUpdateClause::initializeStorageClassArray (SgOmpUpdateClauseStorageArray); ;
5079 0 : assert ( storageClassIndex == sizeOfActualPool );
5080 : }
5081 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDepobjUpdateClause ) ;
5082 0 : std::cout << " SgOmpDepobjUpdateClause has size " << sizeOfActualPool << std::endl;
5083 0 : SgOmpDepobjUpdateClauseStorageClass* SgOmpDepobjUpdateClauseStorageArray = NULL;
5084 0 : if ( 0 < sizeOfActualPool )
5085 : {
5086 0 : SgOmpDepobjUpdateClauseStorageArray = new SgOmpDepobjUpdateClauseStorageClass[sizeOfActualPool] ;
5087 0 : unsigned long storageClassIndex = SgOmpDepobjUpdateClause::initializeStorageClassArray (SgOmpDepobjUpdateClauseStorageArray); ;
5088 0 : assert ( storageClassIndex == sizeOfActualPool );
5089 : }
5090 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDestroyClause ) ;
5091 0 : std::cout << " SgOmpDestroyClause has size " << sizeOfActualPool << std::endl;
5092 0 : SgOmpDestroyClauseStorageClass* SgOmpDestroyClauseStorageArray = NULL;
5093 0 : if ( 0 < sizeOfActualPool )
5094 : {
5095 0 : SgOmpDestroyClauseStorageArray = new SgOmpDestroyClauseStorageClass[sizeOfActualPool] ;
5096 0 : unsigned long storageClassIndex = SgOmpDestroyClause::initializeStorageClassArray (SgOmpDestroyClauseStorageArray); ;
5097 0 : assert ( storageClassIndex == sizeOfActualPool );
5098 : }
5099 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpCaptureClause ) ;
5100 0 : std::cout << " SgOmpCaptureClause has size " << sizeOfActualPool << std::endl;
5101 0 : SgOmpCaptureClauseStorageClass* SgOmpCaptureClauseStorageArray = NULL;
5102 0 : if ( 0 < sizeOfActualPool )
5103 : {
5104 0 : SgOmpCaptureClauseStorageArray = new SgOmpCaptureClauseStorageClass[sizeOfActualPool] ;
5105 0 : unsigned long storageClassIndex = SgOmpCaptureClause::initializeStorageClassArray (SgOmpCaptureClauseStorageArray); ;
5106 0 : assert ( storageClassIndex == sizeOfActualPool );
5107 : }
5108 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSeqCstClause ) ;
5109 0 : std::cout << " SgOmpSeqCstClause has size " << sizeOfActualPool << std::endl;
5110 0 : SgOmpSeqCstClauseStorageClass* SgOmpSeqCstClauseStorageArray = NULL;
5111 0 : if ( 0 < sizeOfActualPool )
5112 : {
5113 0 : SgOmpSeqCstClauseStorageArray = new SgOmpSeqCstClauseStorageClass[sizeOfActualPool] ;
5114 0 : unsigned long storageClassIndex = SgOmpSeqCstClause::initializeStorageClassArray (SgOmpSeqCstClauseStorageArray); ;
5115 0 : assert ( storageClassIndex == sizeOfActualPool );
5116 : }
5117 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAcqRelClause ) ;
5118 0 : std::cout << " SgOmpAcqRelClause has size " << sizeOfActualPool << std::endl;
5119 0 : SgOmpAcqRelClauseStorageClass* SgOmpAcqRelClauseStorageArray = NULL;
5120 0 : if ( 0 < sizeOfActualPool )
5121 : {
5122 0 : SgOmpAcqRelClauseStorageArray = new SgOmpAcqRelClauseStorageClass[sizeOfActualPool] ;
5123 0 : unsigned long storageClassIndex = SgOmpAcqRelClause::initializeStorageClassArray (SgOmpAcqRelClauseStorageArray); ;
5124 0 : assert ( storageClassIndex == sizeOfActualPool );
5125 : }
5126 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpReleaseClause ) ;
5127 0 : std::cout << " SgOmpReleaseClause has size " << sizeOfActualPool << std::endl;
5128 0 : SgOmpReleaseClauseStorageClass* SgOmpReleaseClauseStorageArray = NULL;
5129 0 : if ( 0 < sizeOfActualPool )
5130 : {
5131 0 : SgOmpReleaseClauseStorageArray = new SgOmpReleaseClauseStorageClass[sizeOfActualPool] ;
5132 0 : unsigned long storageClassIndex = SgOmpReleaseClause::initializeStorageClassArray (SgOmpReleaseClauseStorageArray); ;
5133 0 : assert ( storageClassIndex == sizeOfActualPool );
5134 : }
5135 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAcquireClause ) ;
5136 0 : std::cout << " SgOmpAcquireClause has size " << sizeOfActualPool << std::endl;
5137 0 : SgOmpAcquireClauseStorageClass* SgOmpAcquireClauseStorageArray = NULL;
5138 0 : if ( 0 < sizeOfActualPool )
5139 : {
5140 0 : SgOmpAcquireClauseStorageArray = new SgOmpAcquireClauseStorageClass[sizeOfActualPool] ;
5141 0 : unsigned long storageClassIndex = SgOmpAcquireClause::initializeStorageClassArray (SgOmpAcquireClauseStorageArray); ;
5142 0 : assert ( storageClassIndex == sizeOfActualPool );
5143 : }
5144 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpReverseOffloadClause ) ;
5145 0 : std::cout << " SgOmpReverseOffloadClause has size " << sizeOfActualPool << std::endl;
5146 0 : SgOmpReverseOffloadClauseStorageClass* SgOmpReverseOffloadClauseStorageArray = NULL;
5147 0 : if ( 0 < sizeOfActualPool )
5148 : {
5149 0 : SgOmpReverseOffloadClauseStorageArray = new SgOmpReverseOffloadClauseStorageClass[sizeOfActualPool] ;
5150 0 : unsigned long storageClassIndex = SgOmpReverseOffloadClause::initializeStorageClassArray (SgOmpReverseOffloadClauseStorageArray); ;
5151 0 : assert ( storageClassIndex == sizeOfActualPool );
5152 : }
5153 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUnifiedAddressClause ) ;
5154 0 : std::cout << " SgOmpUnifiedAddressClause has size " << sizeOfActualPool << std::endl;
5155 0 : SgOmpUnifiedAddressClauseStorageClass* SgOmpUnifiedAddressClauseStorageArray = NULL;
5156 0 : if ( 0 < sizeOfActualPool )
5157 : {
5158 0 : SgOmpUnifiedAddressClauseStorageArray = new SgOmpUnifiedAddressClauseStorageClass[sizeOfActualPool] ;
5159 0 : unsigned long storageClassIndex = SgOmpUnifiedAddressClause::initializeStorageClassArray (SgOmpUnifiedAddressClauseStorageArray); ;
5160 0 : assert ( storageClassIndex == sizeOfActualPool );
5161 : }
5162 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUnifiedSharedMemoryClause ) ;
5163 0 : std::cout << " SgOmpUnifiedSharedMemoryClause has size " << sizeOfActualPool << std::endl;
5164 0 : SgOmpUnifiedSharedMemoryClauseStorageClass* SgOmpUnifiedSharedMemoryClauseStorageArray = NULL;
5165 0 : if ( 0 < sizeOfActualPool )
5166 : {
5167 0 : SgOmpUnifiedSharedMemoryClauseStorageArray = new SgOmpUnifiedSharedMemoryClauseStorageClass[sizeOfActualPool] ;
5168 0 : unsigned long storageClassIndex = SgOmpUnifiedSharedMemoryClause::initializeStorageClassArray (SgOmpUnifiedSharedMemoryClauseStorageArray); ;
5169 0 : assert ( storageClassIndex == sizeOfActualPool );
5170 : }
5171 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDynamicAllocatorsClause ) ;
5172 0 : std::cout << " SgOmpDynamicAllocatorsClause has size " << sizeOfActualPool << std::endl;
5173 0 : SgOmpDynamicAllocatorsClauseStorageClass* SgOmpDynamicAllocatorsClauseStorageArray = NULL;
5174 0 : if ( 0 < sizeOfActualPool )
5175 : {
5176 0 : SgOmpDynamicAllocatorsClauseStorageArray = new SgOmpDynamicAllocatorsClauseStorageClass[sizeOfActualPool] ;
5177 0 : unsigned long storageClassIndex = SgOmpDynamicAllocatorsClause::initializeStorageClassArray (SgOmpDynamicAllocatorsClauseStorageArray); ;
5178 0 : assert ( storageClassIndex == sizeOfActualPool );
5179 : }
5180 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAtomicDefaultMemOrderClause ) ;
5181 0 : std::cout << " SgOmpAtomicDefaultMemOrderClause has size " << sizeOfActualPool << std::endl;
5182 0 : SgOmpAtomicDefaultMemOrderClauseStorageClass* SgOmpAtomicDefaultMemOrderClauseStorageArray = NULL;
5183 0 : if ( 0 < sizeOfActualPool )
5184 : {
5185 0 : SgOmpAtomicDefaultMemOrderClauseStorageArray = new SgOmpAtomicDefaultMemOrderClauseStorageClass[sizeOfActualPool] ;
5186 0 : unsigned long storageClassIndex = SgOmpAtomicDefaultMemOrderClause::initializeStorageClassArray (SgOmpAtomicDefaultMemOrderClauseStorageArray); ;
5187 0 : assert ( storageClassIndex == sizeOfActualPool );
5188 : }
5189 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpExtImplementationDefinedRequirementClause ) ;
5190 0 : std::cout << " SgOmpExtImplementationDefinedRequirementClause has size " << sizeOfActualPool << std::endl;
5191 0 : SgOmpExtImplementationDefinedRequirementClauseStorageClass* SgOmpExtImplementationDefinedRequirementClauseStorageArray = NULL;
5192 0 : if ( 0 < sizeOfActualPool )
5193 : {
5194 0 : SgOmpExtImplementationDefinedRequirementClauseStorageArray = new SgOmpExtImplementationDefinedRequirementClauseStorageClass[sizeOfActualPool] ;
5195 0 : unsigned long storageClassIndex = SgOmpExtImplementationDefinedRequirementClause::initializeStorageClassArray (SgOmpExtImplementationDefinedRequirementClauseStorageArray); ;
5196 0 : assert ( storageClassIndex == sizeOfActualPool );
5197 : }
5198 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpRelaxedClause ) ;
5199 0 : std::cout << " SgOmpRelaxedClause has size " << sizeOfActualPool << std::endl;
5200 0 : SgOmpRelaxedClauseStorageClass* SgOmpRelaxedClauseStorageArray = NULL;
5201 0 : if ( 0 < sizeOfActualPool )
5202 : {
5203 0 : SgOmpRelaxedClauseStorageArray = new SgOmpRelaxedClauseStorageClass[sizeOfActualPool] ;
5204 0 : unsigned long storageClassIndex = SgOmpRelaxedClause::initializeStorageClassArray (SgOmpRelaxedClauseStorageArray); ;
5205 0 : assert ( storageClassIndex == sizeOfActualPool );
5206 : }
5207 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpParallelClause ) ;
5208 0 : std::cout << " SgOmpParallelClause has size " << sizeOfActualPool << std::endl;
5209 0 : SgOmpParallelClauseStorageClass* SgOmpParallelClauseStorageArray = NULL;
5210 0 : if ( 0 < sizeOfActualPool )
5211 : {
5212 0 : SgOmpParallelClauseStorageArray = new SgOmpParallelClauseStorageClass[sizeOfActualPool] ;
5213 0 : unsigned long storageClassIndex = SgOmpParallelClause::initializeStorageClassArray (SgOmpParallelClauseStorageArray); ;
5214 0 : assert ( storageClassIndex == sizeOfActualPool );
5215 : }
5216 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSectionsClause ) ;
5217 0 : std::cout << " SgOmpSectionsClause has size " << sizeOfActualPool << std::endl;
5218 0 : SgOmpSectionsClauseStorageClass* SgOmpSectionsClauseStorageArray = NULL;
5219 0 : if ( 0 < sizeOfActualPool )
5220 : {
5221 0 : SgOmpSectionsClauseStorageArray = new SgOmpSectionsClauseStorageClass[sizeOfActualPool] ;
5222 0 : unsigned long storageClassIndex = SgOmpSectionsClause::initializeStorageClassArray (SgOmpSectionsClauseStorageArray); ;
5223 0 : assert ( storageClassIndex == sizeOfActualPool );
5224 : }
5225 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpForClause ) ;
5226 0 : std::cout << " SgOmpForClause has size " << sizeOfActualPool << std::endl;
5227 0 : SgOmpForClauseStorageClass* SgOmpForClauseStorageArray = NULL;
5228 0 : if ( 0 < sizeOfActualPool )
5229 : {
5230 0 : SgOmpForClauseStorageArray = new SgOmpForClauseStorageClass[sizeOfActualPool] ;
5231 0 : unsigned long storageClassIndex = SgOmpForClause::initializeStorageClassArray (SgOmpForClauseStorageArray); ;
5232 0 : assert ( storageClassIndex == sizeOfActualPool );
5233 : }
5234 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskgroupClause ) ;
5235 0 : std::cout << " SgOmpTaskgroupClause has size " << sizeOfActualPool << std::endl;
5236 0 : SgOmpTaskgroupClauseStorageClass* SgOmpTaskgroupClauseStorageArray = NULL;
5237 0 : if ( 0 < sizeOfActualPool )
5238 : {
5239 0 : SgOmpTaskgroupClauseStorageArray = new SgOmpTaskgroupClauseStorageClass[sizeOfActualPool] ;
5240 0 : unsigned long storageClassIndex = SgOmpTaskgroupClause::initializeStorageClassArray (SgOmpTaskgroupClauseStorageArray); ;
5241 0 : assert ( storageClassIndex == sizeOfActualPool );
5242 : }
5243 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirNumUnitsField ) ;
5244 0 : std::cout << " SgUpirNumUnitsField has size " << sizeOfActualPool << std::endl;
5245 0 : SgUpirNumUnitsFieldStorageClass* SgUpirNumUnitsFieldStorageArray = NULL;
5246 0 : if ( 0 < sizeOfActualPool )
5247 : {
5248 0 : SgUpirNumUnitsFieldStorageArray = new SgUpirNumUnitsFieldStorageClass[sizeOfActualPool] ;
5249 0 : unsigned long storageClassIndex = SgUpirNumUnitsField::initializeStorageClassArray (SgUpirNumUnitsFieldStorageArray); ;
5250 0 : assert ( storageClassIndex == sizeOfActualPool );
5251 : }
5252 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNumTeamsClause ) ;
5253 0 : std::cout << " SgOmpNumTeamsClause has size " << sizeOfActualPool << std::endl;
5254 0 : SgOmpNumTeamsClauseStorageClass* SgOmpNumTeamsClauseStorageArray = NULL;
5255 0 : if ( 0 < sizeOfActualPool )
5256 : {
5257 0 : SgOmpNumTeamsClauseStorageArray = new SgOmpNumTeamsClauseStorageClass[sizeOfActualPool] ;
5258 0 : unsigned long storageClassIndex = SgOmpNumTeamsClause::initializeStorageClassArray (SgOmpNumTeamsClauseStorageArray); ;
5259 0 : assert ( storageClassIndex == sizeOfActualPool );
5260 : }
5261 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpGrainsizeClause ) ;
5262 0 : std::cout << " SgOmpGrainsizeClause has size " << sizeOfActualPool << std::endl;
5263 0 : SgOmpGrainsizeClauseStorageClass* SgOmpGrainsizeClauseStorageArray = NULL;
5264 0 : if ( 0 < sizeOfActualPool )
5265 : {
5266 0 : SgOmpGrainsizeClauseStorageArray = new SgOmpGrainsizeClauseStorageClass[sizeOfActualPool] ;
5267 0 : unsigned long storageClassIndex = SgOmpGrainsizeClause::initializeStorageClassArray (SgOmpGrainsizeClauseStorageArray); ;
5268 0 : assert ( storageClassIndex == sizeOfActualPool );
5269 : }
5270 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDetachClause ) ;
5271 0 : std::cout << " SgOmpDetachClause has size " << sizeOfActualPool << std::endl;
5272 0 : SgOmpDetachClauseStorageClass* SgOmpDetachClauseStorageArray = NULL;
5273 0 : if ( 0 < sizeOfActualPool )
5274 : {
5275 0 : SgOmpDetachClauseStorageArray = new SgOmpDetachClauseStorageClass[sizeOfActualPool] ;
5276 0 : unsigned long storageClassIndex = SgOmpDetachClause::initializeStorageClassArray (SgOmpDetachClauseStorageArray); ;
5277 0 : assert ( storageClassIndex == sizeOfActualPool );
5278 : }
5279 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNumTasksClause ) ;
5280 0 : std::cout << " SgOmpNumTasksClause has size " << sizeOfActualPool << std::endl;
5281 0 : SgOmpNumTasksClauseStorageClass* SgOmpNumTasksClauseStorageArray = NULL;
5282 0 : if ( 0 < sizeOfActualPool )
5283 : {
5284 0 : SgOmpNumTasksClauseStorageArray = new SgOmpNumTasksClauseStorageClass[sizeOfActualPool] ;
5285 0 : unsigned long storageClassIndex = SgOmpNumTasksClause::initializeStorageClassArray (SgOmpNumTasksClauseStorageArray); ;
5286 0 : assert ( storageClassIndex == sizeOfActualPool );
5287 : }
5288 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNogroupClause ) ;
5289 0 : std::cout << " SgOmpNogroupClause has size " << sizeOfActualPool << std::endl;
5290 0 : SgOmpNogroupClauseStorageClass* SgOmpNogroupClauseStorageArray = NULL;
5291 0 : if ( 0 < sizeOfActualPool )
5292 : {
5293 0 : SgOmpNogroupClauseStorageArray = new SgOmpNogroupClauseStorageClass[sizeOfActualPool] ;
5294 0 : unsigned long storageClassIndex = SgOmpNogroupClause::initializeStorageClassArray (SgOmpNogroupClauseStorageArray); ;
5295 0 : assert ( storageClassIndex == sizeOfActualPool );
5296 : }
5297 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpHintClause ) ;
5298 0 : std::cout << " SgOmpHintClause has size " << sizeOfActualPool << std::endl;
5299 0 : SgOmpHintClauseStorageClass* SgOmpHintClauseStorageArray = NULL;
5300 0 : if ( 0 < sizeOfActualPool )
5301 : {
5302 0 : SgOmpHintClauseStorageArray = new SgOmpHintClauseStorageClass[sizeOfActualPool] ;
5303 0 : unsigned long storageClassIndex = SgOmpHintClause::initializeStorageClassArray (SgOmpHintClauseStorageArray); ;
5304 0 : assert ( storageClassIndex == sizeOfActualPool );
5305 : }
5306 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpOrderClause ) ;
5307 0 : std::cout << " SgOmpOrderClause has size " << sizeOfActualPool << std::endl;
5308 0 : SgOmpOrderClauseStorageClass* SgOmpOrderClauseStorageArray = NULL;
5309 0 : if ( 0 < sizeOfActualPool )
5310 : {
5311 0 : SgOmpOrderClauseStorageArray = new SgOmpOrderClauseStorageClass[sizeOfActualPool] ;
5312 0 : unsigned long storageClassIndex = SgOmpOrderClause::initializeStorageClassArray (SgOmpOrderClauseStorageArray); ;
5313 0 : assert ( storageClassIndex == sizeOfActualPool );
5314 : }
5315 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDistScheduleClause ) ;
5316 0 : std::cout << " SgOmpDistScheduleClause has size " << sizeOfActualPool << std::endl;
5317 0 : SgOmpDistScheduleClauseStorageClass* SgOmpDistScheduleClauseStorageArray = NULL;
5318 0 : if ( 0 < sizeOfActualPool )
5319 : {
5320 0 : SgOmpDistScheduleClauseStorageArray = new SgOmpDistScheduleClauseStorageClass[sizeOfActualPool] ;
5321 0 : unsigned long storageClassIndex = SgOmpDistScheduleClause::initializeStorageClassArray (SgOmpDistScheduleClauseStorageArray); ;
5322 0 : assert ( storageClassIndex == sizeOfActualPool );
5323 : }
5324 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpBindClause ) ;
5325 0 : std::cout << " SgOmpBindClause has size " << sizeOfActualPool << std::endl;
5326 0 : SgOmpBindClauseStorageClass* SgOmpBindClauseStorageArray = NULL;
5327 0 : if ( 0 < sizeOfActualPool )
5328 : {
5329 0 : SgOmpBindClauseStorageArray = new SgOmpBindClauseStorageClass[sizeOfActualPool] ;
5330 0 : unsigned long storageClassIndex = SgOmpBindClause::initializeStorageClassArray (SgOmpBindClauseStorageArray); ;
5331 0 : assert ( storageClassIndex == sizeOfActualPool );
5332 : }
5333 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNontemporalClause ) ;
5334 0 : std::cout << " SgOmpNontemporalClause has size " << sizeOfActualPool << std::endl;
5335 0 : SgOmpNontemporalClauseStorageClass* SgOmpNontemporalClauseStorageArray = NULL;
5336 0 : if ( 0 < sizeOfActualPool )
5337 : {
5338 0 : SgOmpNontemporalClauseStorageArray = new SgOmpNontemporalClauseStorageClass[sizeOfActualPool] ;
5339 0 : unsigned long storageClassIndex = SgOmpNontemporalClause::initializeStorageClassArray (SgOmpNontemporalClauseStorageArray); ;
5340 0 : assert ( storageClassIndex == sizeOfActualPool );
5341 : }
5342 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpInclusiveClause ) ;
5343 0 : std::cout << " SgOmpInclusiveClause has size " << sizeOfActualPool << std::endl;
5344 0 : SgOmpInclusiveClauseStorageClass* SgOmpInclusiveClauseStorageArray = NULL;
5345 0 : if ( 0 < sizeOfActualPool )
5346 : {
5347 0 : SgOmpInclusiveClauseStorageArray = new SgOmpInclusiveClauseStorageClass[sizeOfActualPool] ;
5348 0 : unsigned long storageClassIndex = SgOmpInclusiveClause::initializeStorageClassArray (SgOmpInclusiveClauseStorageArray); ;
5349 0 : assert ( storageClassIndex == sizeOfActualPool );
5350 : }
5351 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpExclusiveClause ) ;
5352 0 : std::cout << " SgOmpExclusiveClause has size " << sizeOfActualPool << std::endl;
5353 0 : SgOmpExclusiveClauseStorageClass* SgOmpExclusiveClauseStorageArray = NULL;
5354 0 : if ( 0 < sizeOfActualPool )
5355 : {
5356 0 : SgOmpExclusiveClauseStorageArray = new SgOmpExclusiveClauseStorageClass[sizeOfActualPool] ;
5357 0 : unsigned long storageClassIndex = SgOmpExclusiveClause::initializeStorageClassArray (SgOmpExclusiveClauseStorageArray); ;
5358 0 : assert ( storageClassIndex == sizeOfActualPool );
5359 : }
5360 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpIsDevicePtrClause ) ;
5361 0 : std::cout << " SgOmpIsDevicePtrClause has size " << sizeOfActualPool << std::endl;
5362 0 : SgOmpIsDevicePtrClauseStorageClass* SgOmpIsDevicePtrClauseStorageArray = NULL;
5363 0 : if ( 0 < sizeOfActualPool )
5364 : {
5365 0 : SgOmpIsDevicePtrClauseStorageArray = new SgOmpIsDevicePtrClauseStorageClass[sizeOfActualPool] ;
5366 0 : unsigned long storageClassIndex = SgOmpIsDevicePtrClause::initializeStorageClassArray (SgOmpIsDevicePtrClauseStorageArray); ;
5367 0 : assert ( storageClassIndex == sizeOfActualPool );
5368 : }
5369 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUseDevicePtrClause ) ;
5370 0 : std::cout << " SgOmpUseDevicePtrClause has size " << sizeOfActualPool << std::endl;
5371 0 : SgOmpUseDevicePtrClauseStorageClass* SgOmpUseDevicePtrClauseStorageArray = NULL;
5372 0 : if ( 0 < sizeOfActualPool )
5373 : {
5374 0 : SgOmpUseDevicePtrClauseStorageArray = new SgOmpUseDevicePtrClauseStorageClass[sizeOfActualPool] ;
5375 0 : unsigned long storageClassIndex = SgOmpUseDevicePtrClause::initializeStorageClassArray (SgOmpUseDevicePtrClauseStorageArray); ;
5376 0 : assert ( storageClassIndex == sizeOfActualPool );
5377 : }
5378 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUseDeviceAddrClause ) ;
5379 0 : std::cout << " SgOmpUseDeviceAddrClause has size " << sizeOfActualPool << std::endl;
5380 0 : SgOmpUseDeviceAddrClauseStorageClass* SgOmpUseDeviceAddrClauseStorageArray = NULL;
5381 0 : if ( 0 < sizeOfActualPool )
5382 : {
5383 0 : SgOmpUseDeviceAddrClauseStorageArray = new SgOmpUseDeviceAddrClauseStorageClass[sizeOfActualPool] ;
5384 0 : unsigned long storageClassIndex = SgOmpUseDeviceAddrClause::initializeStorageClassArray (SgOmpUseDeviceAddrClauseStorageArray); ;
5385 0 : assert ( storageClassIndex == sizeOfActualPool );
5386 : }
5387 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpThreadLimitClause ) ;
5388 0 : std::cout << " SgOmpThreadLimitClause has size " << sizeOfActualPool << std::endl;
5389 0 : SgOmpThreadLimitClauseStorageClass* SgOmpThreadLimitClauseStorageArray = NULL;
5390 0 : if ( 0 < sizeOfActualPool )
5391 : {
5392 0 : SgOmpThreadLimitClauseStorageArray = new SgOmpThreadLimitClauseStorageClass[sizeOfActualPool] ;
5393 0 : unsigned long storageClassIndex = SgOmpThreadLimitClause::initializeStorageClassArray (SgOmpThreadLimitClauseStorageArray); ;
5394 0 : assert ( storageClassIndex == sizeOfActualPool );
5395 : }
5396 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpOrderedClause ) ;
5397 0 : std::cout << " SgOmpOrderedClause has size " << sizeOfActualPool << std::endl;
5398 0 : SgOmpOrderedClauseStorageClass* SgOmpOrderedClauseStorageArray = NULL;
5399 0 : if ( 0 < sizeOfActualPool )
5400 : {
5401 0 : SgOmpOrderedClauseStorageArray = new SgOmpOrderedClauseStorageClass[sizeOfActualPool] ;
5402 0 : unsigned long storageClassIndex = SgOmpOrderedClause::initializeStorageClassArray (SgOmpOrderedClauseStorageArray); ;
5403 0 : assert ( storageClassIndex == sizeOfActualPool );
5404 : }
5405 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpPrivateClause ) ;
5406 0 : std::cout << " SgOmpPrivateClause has size " << sizeOfActualPool << std::endl;
5407 0 : SgOmpPrivateClauseStorageClass* SgOmpPrivateClauseStorageArray = NULL;
5408 0 : if ( 0 < sizeOfActualPool )
5409 : {
5410 0 : SgOmpPrivateClauseStorageArray = new SgOmpPrivateClauseStorageClass[sizeOfActualPool] ;
5411 0 : unsigned long storageClassIndex = SgOmpPrivateClause::initializeStorageClassArray (SgOmpPrivateClauseStorageArray); ;
5412 0 : assert ( storageClassIndex == sizeOfActualPool );
5413 : }
5414 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpReductionClause ) ;
5415 0 : std::cout << " SgOmpReductionClause has size " << sizeOfActualPool << std::endl;
5416 0 : SgOmpReductionClauseStorageClass* SgOmpReductionClauseStorageArray = NULL;
5417 0 : if ( 0 < sizeOfActualPool )
5418 : {
5419 0 : SgOmpReductionClauseStorageArray = new SgOmpReductionClauseStorageClass[sizeOfActualPool] ;
5420 0 : unsigned long storageClassIndex = SgOmpReductionClause::initializeStorageClassArray (SgOmpReductionClauseStorageArray); ;
5421 0 : assert ( storageClassIndex == sizeOfActualPool );
5422 : }
5423 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpInReductionClause ) ;
5424 0 : std::cout << " SgOmpInReductionClause has size " << sizeOfActualPool << std::endl;
5425 0 : SgOmpInReductionClauseStorageClass* SgOmpInReductionClauseStorageArray = NULL;
5426 0 : if ( 0 < sizeOfActualPool )
5427 : {
5428 0 : SgOmpInReductionClauseStorageArray = new SgOmpInReductionClauseStorageClass[sizeOfActualPool] ;
5429 0 : unsigned long storageClassIndex = SgOmpInReductionClause::initializeStorageClassArray (SgOmpInReductionClauseStorageArray); ;
5430 0 : assert ( storageClassIndex == sizeOfActualPool );
5431 : }
5432 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpTaskReductionClause ) ;
5433 0 : std::cout << " SgOmpTaskReductionClause has size " << sizeOfActualPool << std::endl;
5434 0 : SgOmpTaskReductionClauseStorageClass* SgOmpTaskReductionClauseStorageArray = NULL;
5435 0 : if ( 0 < sizeOfActualPool )
5436 : {
5437 0 : SgOmpTaskReductionClauseStorageArray = new SgOmpTaskReductionClauseStorageClass[sizeOfActualPool] ;
5438 0 : unsigned long storageClassIndex = SgOmpTaskReductionClause::initializeStorageClassArray (SgOmpTaskReductionClauseStorageArray); ;
5439 0 : assert ( storageClassIndex == sizeOfActualPool );
5440 : }
5441 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDefaultmapClause ) ;
5442 0 : std::cout << " SgOmpDefaultmapClause has size " << sizeOfActualPool << std::endl;
5443 0 : SgOmpDefaultmapClauseStorageClass* SgOmpDefaultmapClauseStorageArray = NULL;
5444 0 : if ( 0 < sizeOfActualPool )
5445 : {
5446 0 : SgOmpDefaultmapClauseStorageArray = new SgOmpDefaultmapClauseStorageClass[sizeOfActualPool] ;
5447 0 : unsigned long storageClassIndex = SgOmpDefaultmapClause::initializeStorageClassArray (SgOmpDefaultmapClauseStorageArray); ;
5448 0 : assert ( storageClassIndex == sizeOfActualPool );
5449 : }
5450 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpScheduleClause ) ;
5451 0 : std::cout << " SgOmpScheduleClause has size " << sizeOfActualPool << std::endl;
5452 0 : SgOmpScheduleClauseStorageClass* SgOmpScheduleClauseStorageArray = NULL;
5453 0 : if ( 0 < sizeOfActualPool )
5454 : {
5455 0 : SgOmpScheduleClauseStorageArray = new SgOmpScheduleClauseStorageClass[sizeOfActualPool] ;
5456 0 : unsigned long storageClassIndex = SgOmpScheduleClause::initializeStorageClassArray (SgOmpScheduleClauseStorageArray); ;
5457 0 : assert ( storageClassIndex == sizeOfActualPool );
5458 : }
5459 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSharedClause ) ;
5460 0 : std::cout << " SgOmpSharedClause has size " << sizeOfActualPool << std::endl;
5461 0 : SgOmpSharedClauseStorageClass* SgOmpSharedClauseStorageArray = NULL;
5462 0 : if ( 0 < sizeOfActualPool )
5463 : {
5464 0 : SgOmpSharedClauseStorageArray = new SgOmpSharedClauseStorageClass[sizeOfActualPool] ;
5465 0 : unsigned long storageClassIndex = SgOmpSharedClause::initializeStorageClassArray (SgOmpSharedClauseStorageArray); ;
5466 0 : assert ( storageClassIndex == sizeOfActualPool );
5467 : }
5468 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUntiedClause ) ;
5469 0 : std::cout << " SgOmpUntiedClause has size " << sizeOfActualPool << std::endl;
5470 0 : SgOmpUntiedClauseStorageClass* SgOmpUntiedClauseStorageArray = NULL;
5471 0 : if ( 0 < sizeOfActualPool )
5472 : {
5473 0 : SgOmpUntiedClauseStorageArray = new SgOmpUntiedClauseStorageClass[sizeOfActualPool] ;
5474 0 : unsigned long storageClassIndex = SgOmpUntiedClause::initializeStorageClassArray (SgOmpUntiedClauseStorageArray); ;
5475 0 : assert ( storageClassIndex == sizeOfActualPool );
5476 : }
5477 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMergeableClause ) ;
5478 0 : std::cout << " SgOmpMergeableClause has size " << sizeOfActualPool << std::endl;
5479 0 : SgOmpMergeableClauseStorageClass* SgOmpMergeableClauseStorageArray = NULL;
5480 0 : if ( 0 < sizeOfActualPool )
5481 : {
5482 0 : SgOmpMergeableClauseStorageArray = new SgOmpMergeableClauseStorageClass[sizeOfActualPool] ;
5483 0 : unsigned long storageClassIndex = SgOmpMergeableClause::initializeStorageClassArray (SgOmpMergeableClauseStorageArray); ;
5484 0 : assert ( storageClassIndex == sizeOfActualPool );
5485 : }
5486 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpVariablesClause ) ;
5487 0 : std::cout << " SgOmpVariablesClause has size " << sizeOfActualPool << std::endl;
5488 0 : SgOmpVariablesClauseStorageClass* SgOmpVariablesClauseStorageArray = NULL;
5489 0 : if ( 0 < sizeOfActualPool )
5490 : {
5491 0 : SgOmpVariablesClauseStorageArray = new SgOmpVariablesClauseStorageClass[sizeOfActualPool] ;
5492 0 : unsigned long storageClassIndex = SgOmpVariablesClause::initializeStorageClassArray (SgOmpVariablesClauseStorageArray); ;
5493 0 : assert ( storageClassIndex == sizeOfActualPool );
5494 : }
5495 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpMapClause ) ;
5496 0 : std::cout << " SgOmpMapClause has size " << sizeOfActualPool << std::endl;
5497 0 : SgOmpMapClauseStorageClass* SgOmpMapClauseStorageArray = NULL;
5498 0 : if ( 0 < sizeOfActualPool )
5499 : {
5500 0 : SgOmpMapClauseStorageArray = new SgOmpMapClauseStorageClass[sizeOfActualPool] ;
5501 0 : unsigned long storageClassIndex = SgOmpMapClause::initializeStorageClassArray (SgOmpMapClauseStorageArray); ;
5502 0 : assert ( storageClassIndex == sizeOfActualPool );
5503 : }
5504 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSafelenClause ) ;
5505 0 : std::cout << " SgOmpSafelenClause has size " << sizeOfActualPool << std::endl;
5506 0 : SgOmpSafelenClauseStorageClass* SgOmpSafelenClauseStorageArray = NULL;
5507 0 : if ( 0 < sizeOfActualPool )
5508 : {
5509 0 : SgOmpSafelenClauseStorageArray = new SgOmpSafelenClauseStorageClass[sizeOfActualPool] ;
5510 0 : unsigned long storageClassIndex = SgOmpSafelenClause::initializeStorageClassArray (SgOmpSafelenClauseStorageArray); ;
5511 0 : assert ( storageClassIndex == sizeOfActualPool );
5512 : }
5513 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSimdlenClause ) ;
5514 0 : std::cout << " SgOmpSimdlenClause has size " << sizeOfActualPool << std::endl;
5515 0 : SgOmpSimdlenClauseStorageClass* SgOmpSimdlenClauseStorageArray = NULL;
5516 0 : if ( 0 < sizeOfActualPool )
5517 : {
5518 0 : SgOmpSimdlenClauseStorageArray = new SgOmpSimdlenClauseStorageClass[sizeOfActualPool] ;
5519 0 : unsigned long storageClassIndex = SgOmpSimdlenClause::initializeStorageClassArray (SgOmpSimdlenClauseStorageArray); ;
5520 0 : assert ( storageClassIndex == sizeOfActualPool );
5521 : }
5522 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpLinearClause ) ;
5523 0 : std::cout << " SgOmpLinearClause has size " << sizeOfActualPool << std::endl;
5524 0 : SgOmpLinearClauseStorageClass* SgOmpLinearClauseStorageArray = NULL;
5525 0 : if ( 0 < sizeOfActualPool )
5526 : {
5527 0 : SgOmpLinearClauseStorageArray = new SgOmpLinearClauseStorageClass[sizeOfActualPool] ;
5528 0 : unsigned long storageClassIndex = SgOmpLinearClause::initializeStorageClassArray (SgOmpLinearClauseStorageArray); ;
5529 0 : assert ( storageClassIndex == sizeOfActualPool );
5530 : }
5531 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpUniformClause ) ;
5532 0 : std::cout << " SgOmpUniformClause has size " << sizeOfActualPool << std::endl;
5533 0 : SgOmpUniformClauseStorageClass* SgOmpUniformClauseStorageArray = NULL;
5534 0 : if ( 0 < sizeOfActualPool )
5535 : {
5536 0 : SgOmpUniformClauseStorageArray = new SgOmpUniformClauseStorageClass[sizeOfActualPool] ;
5537 0 : unsigned long storageClassIndex = SgOmpUniformClause::initializeStorageClassArray (SgOmpUniformClauseStorageArray); ;
5538 0 : assert ( storageClassIndex == sizeOfActualPool );
5539 : }
5540 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAlignedClause ) ;
5541 0 : std::cout << " SgOmpAlignedClause has size " << sizeOfActualPool << std::endl;
5542 0 : SgOmpAlignedClauseStorageClass* SgOmpAlignedClauseStorageArray = NULL;
5543 0 : if ( 0 < sizeOfActualPool )
5544 : {
5545 0 : SgOmpAlignedClauseStorageArray = new SgOmpAlignedClauseStorageClass[sizeOfActualPool] ;
5546 0 : unsigned long storageClassIndex = SgOmpAlignedClause::initializeStorageClassArray (SgOmpAlignedClauseStorageArray); ;
5547 0 : assert ( storageClassIndex == sizeOfActualPool );
5548 : }
5549 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpProcBindClause ) ;
5550 0 : std::cout << " SgOmpProcBindClause has size " << sizeOfActualPool << std::endl;
5551 0 : SgOmpProcBindClauseStorageClass* SgOmpProcBindClauseStorageArray = NULL;
5552 0 : if ( 0 < sizeOfActualPool )
5553 : {
5554 0 : SgOmpProcBindClauseStorageArray = new SgOmpProcBindClauseStorageClass[sizeOfActualPool] ;
5555 0 : unsigned long storageClassIndex = SgOmpProcBindClause::initializeStorageClassArray (SgOmpProcBindClauseStorageArray); ;
5556 0 : assert ( storageClassIndex == sizeOfActualPool );
5557 : }
5558 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAtomicClause ) ;
5559 0 : std::cout << " SgOmpAtomicClause has size " << sizeOfActualPool << std::endl;
5560 0 : SgOmpAtomicClauseStorageClass* SgOmpAtomicClauseStorageArray = NULL;
5561 0 : if ( 0 < sizeOfActualPool )
5562 : {
5563 0 : SgOmpAtomicClauseStorageArray = new SgOmpAtomicClauseStorageClass[sizeOfActualPool] ;
5564 0 : unsigned long storageClassIndex = SgOmpAtomicClause::initializeStorageClassArray (SgOmpAtomicClauseStorageArray); ;
5565 0 : assert ( storageClassIndex == sizeOfActualPool );
5566 : }
5567 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpInbranchClause ) ;
5568 0 : std::cout << " SgOmpInbranchClause has size " << sizeOfActualPool << std::endl;
5569 0 : SgOmpInbranchClauseStorageClass* SgOmpInbranchClauseStorageArray = NULL;
5570 0 : if ( 0 < sizeOfActualPool )
5571 : {
5572 0 : SgOmpInbranchClauseStorageArray = new SgOmpInbranchClauseStorageClass[sizeOfActualPool] ;
5573 0 : unsigned long storageClassIndex = SgOmpInbranchClause::initializeStorageClassArray (SgOmpInbranchClauseStorageArray); ;
5574 0 : assert ( storageClassIndex == sizeOfActualPool );
5575 : }
5576 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpNotinbranchClause ) ;
5577 0 : std::cout << " SgOmpNotinbranchClause has size " << sizeOfActualPool << std::endl;
5578 0 : SgOmpNotinbranchClauseStorageClass* SgOmpNotinbranchClauseStorageArray = NULL;
5579 0 : if ( 0 < sizeOfActualPool )
5580 : {
5581 0 : SgOmpNotinbranchClauseStorageArray = new SgOmpNotinbranchClauseStorageClass[sizeOfActualPool] ;
5582 0 : unsigned long storageClassIndex = SgOmpNotinbranchClause::initializeStorageClassArray (SgOmpNotinbranchClauseStorageArray); ;
5583 0 : assert ( storageClassIndex == sizeOfActualPool );
5584 : }
5585 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpDependClause ) ;
5586 0 : std::cout << " SgOmpDependClause has size " << sizeOfActualPool << std::endl;
5587 0 : SgOmpDependClauseStorageClass* SgOmpDependClauseStorageArray = NULL;
5588 0 : if ( 0 < sizeOfActualPool )
5589 : {
5590 0 : SgOmpDependClauseStorageArray = new SgOmpDependClauseStorageClass[sizeOfActualPool] ;
5591 0 : unsigned long storageClassIndex = SgOmpDependClause::initializeStorageClassArray (SgOmpDependClauseStorageArray); ;
5592 0 : assert ( storageClassIndex == sizeOfActualPool );
5593 : }
5594 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpAffinityClause ) ;
5595 0 : std::cout << " SgOmpAffinityClause has size " << sizeOfActualPool << std::endl;
5596 0 : SgOmpAffinityClauseStorageClass* SgOmpAffinityClauseStorageArray = NULL;
5597 0 : if ( 0 < sizeOfActualPool )
5598 : {
5599 0 : SgOmpAffinityClauseStorageArray = new SgOmpAffinityClauseStorageClass[sizeOfActualPool] ;
5600 0 : unsigned long storageClassIndex = SgOmpAffinityClause::initializeStorageClassArray (SgOmpAffinityClauseStorageArray); ;
5601 0 : assert ( storageClassIndex == sizeOfActualPool );
5602 : }
5603 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpWhenClause ) ;
5604 0 : std::cout << " SgOmpWhenClause has size " << sizeOfActualPool << std::endl;
5605 0 : SgOmpWhenClauseStorageClass* SgOmpWhenClauseStorageArray = NULL;
5606 0 : if ( 0 < sizeOfActualPool )
5607 : {
5608 0 : SgOmpWhenClauseStorageArray = new SgOmpWhenClauseStorageClass[sizeOfActualPool] ;
5609 0 : unsigned long storageClassIndex = SgOmpWhenClause::initializeStorageClassArray (SgOmpWhenClauseStorageArray); ;
5610 0 : assert ( storageClassIndex == sizeOfActualPool );
5611 : }
5612 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpFullClause ) ;
5613 0 : std::cout << " SgOmpFullClause has size " << sizeOfActualPool << std::endl;
5614 0 : SgOmpFullClauseStorageClass* SgOmpFullClauseStorageArray = NULL;
5615 0 : if ( 0 < sizeOfActualPool )
5616 : {
5617 0 : SgOmpFullClauseStorageArray = new SgOmpFullClauseStorageClass[sizeOfActualPool] ;
5618 0 : unsigned long storageClassIndex = SgOmpFullClause::initializeStorageClassArray (SgOmpFullClauseStorageArray); ;
5619 0 : assert ( storageClassIndex == sizeOfActualPool );
5620 : }
5621 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpPartialClause ) ;
5622 0 : std::cout << " SgOmpPartialClause has size " << sizeOfActualPool << std::endl;
5623 0 : SgOmpPartialClauseStorageClass* SgOmpPartialClauseStorageArray = NULL;
5624 0 : if ( 0 < sizeOfActualPool )
5625 : {
5626 0 : SgOmpPartialClauseStorageArray = new SgOmpPartialClauseStorageClass[sizeOfActualPool] ;
5627 0 : unsigned long storageClassIndex = SgOmpPartialClause::initializeStorageClassArray (SgOmpPartialClauseStorageArray); ;
5628 0 : assert ( storageClassIndex == sizeOfActualPool );
5629 : }
5630 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOmpSizesClause ) ;
5631 0 : std::cout << " SgOmpSizesClause has size " << sizeOfActualPool << std::endl;
5632 0 : SgOmpSizesClauseStorageClass* SgOmpSizesClauseStorageArray = NULL;
5633 0 : if ( 0 < sizeOfActualPool )
5634 : {
5635 0 : SgOmpSizesClauseStorageArray = new SgOmpSizesClauseStorageClass[sizeOfActualPool] ;
5636 0 : unsigned long storageClassIndex = SgOmpSizesClause::initializeStorageClassArray (SgOmpSizesClauseStorageArray); ;
5637 0 : assert ( storageClassIndex == sizeOfActualPool );
5638 : }
5639 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirBranchField ) ;
5640 0 : std::cout << " SgUpirBranchField has size " << sizeOfActualPool << std::endl;
5641 0 : SgUpirBranchFieldStorageClass* SgUpirBranchFieldStorageArray = NULL;
5642 0 : if ( 0 < sizeOfActualPool )
5643 : {
5644 0 : SgUpirBranchFieldStorageArray = new SgUpirBranchFieldStorageClass[sizeOfActualPool] ;
5645 0 : unsigned long storageClassIndex = SgUpirBranchField::initializeStorageClassArray (SgUpirBranchFieldStorageArray); ;
5646 0 : assert ( storageClassIndex == sizeOfActualPool );
5647 : }
5648 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirNestedLevelField ) ;
5649 0 : std::cout << " SgUpirNestedLevelField has size " << sizeOfActualPool << std::endl;
5650 0 : SgUpirNestedLevelFieldStorageClass* SgUpirNestedLevelFieldStorageArray = NULL;
5651 0 : if ( 0 < sizeOfActualPool )
5652 : {
5653 0 : SgUpirNestedLevelFieldStorageArray = new SgUpirNestedLevelFieldStorageClass[sizeOfActualPool] ;
5654 0 : unsigned long storageClassIndex = SgUpirNestedLevelField::initializeStorageClassArray (SgUpirNestedLevelFieldStorageArray); ;
5655 0 : assert ( storageClassIndex == sizeOfActualPool );
5656 : }
5657 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirNestedParentField ) ;
5658 0 : std::cout << " SgUpirNestedParentField has size " << sizeOfActualPool << std::endl;
5659 0 : SgUpirNestedParentFieldStorageClass* SgUpirNestedParentFieldStorageArray = NULL;
5660 0 : if ( 0 < sizeOfActualPool )
5661 : {
5662 0 : SgUpirNestedParentFieldStorageArray = new SgUpirNestedParentFieldStorageClass[sizeOfActualPool] ;
5663 0 : unsigned long storageClassIndex = SgUpirNestedParentField::initializeStorageClassArray (SgUpirNestedParentFieldStorageArray); ;
5664 0 : assert ( storageClassIndex == sizeOfActualPool );
5665 : }
5666 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirNestedChildField ) ;
5667 0 : std::cout << " SgUpirNestedChildField has size " << sizeOfActualPool << std::endl;
5668 0 : SgUpirNestedChildFieldStorageClass* SgUpirNestedChildFieldStorageArray = NULL;
5669 0 : if ( 0 < sizeOfActualPool )
5670 : {
5671 0 : SgUpirNestedChildFieldStorageArray = new SgUpirNestedChildFieldStorageClass[sizeOfActualPool] ;
5672 0 : unsigned long storageClassIndex = SgUpirNestedChildField::initializeStorageClassArray (SgUpirNestedChildFieldStorageArray); ;
5673 0 : assert ( storageClassIndex == sizeOfActualPool );
5674 : }
5675 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirSyncField ) ;
5676 0 : std::cout << " SgUpirSyncField has size " << sizeOfActualPool << std::endl;
5677 0 : SgUpirSyncFieldStorageClass* SgUpirSyncFieldStorageArray = NULL;
5678 0 : if ( 0 < sizeOfActualPool )
5679 : {
5680 0 : SgUpirSyncFieldStorageArray = new SgUpirSyncFieldStorageClass[sizeOfActualPool] ;
5681 0 : unsigned long storageClassIndex = SgUpirSyncField::initializeStorageClassArray (SgUpirSyncFieldStorageArray); ;
5682 0 : assert ( storageClassIndex == sizeOfActualPool );
5683 : }
5684 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirDataField ) ;
5685 0 : std::cout << " SgUpirDataField has size " << sizeOfActualPool << std::endl;
5686 0 : SgUpirDataFieldStorageClass* SgUpirDataFieldStorageArray = NULL;
5687 0 : if ( 0 < sizeOfActualPool )
5688 : {
5689 0 : SgUpirDataFieldStorageArray = new SgUpirDataFieldStorageClass[sizeOfActualPool] ;
5690 0 : unsigned long storageClassIndex = SgUpirDataField::initializeStorageClassArray (SgUpirDataFieldStorageArray); ;
5691 0 : assert ( storageClassIndex == sizeOfActualPool );
5692 : }
5693 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirDataItemField ) ;
5694 0 : std::cout << " SgUpirDataItemField has size " << sizeOfActualPool << std::endl;
5695 0 : SgUpirDataItemFieldStorageClass* SgUpirDataItemFieldStorageArray = NULL;
5696 0 : if ( 0 < sizeOfActualPool )
5697 : {
5698 0 : SgUpirDataItemFieldStorageArray = new SgUpirDataItemFieldStorageClass[sizeOfActualPool] ;
5699 0 : unsigned long storageClassIndex = SgUpirDataItemField::initializeStorageClassArray (SgUpirDataItemFieldStorageArray); ;
5700 0 : assert ( storageClassIndex == sizeOfActualPool );
5701 : }
5702 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpirTargetField ) ;
5703 0 : std::cout << " SgUpirTargetField has size " << sizeOfActualPool << std::endl;
5704 0 : SgUpirTargetFieldStorageClass* SgUpirTargetFieldStorageArray = NULL;
5705 0 : if ( 0 < sizeOfActualPool )
5706 : {
5707 0 : SgUpirTargetFieldStorageArray = new SgUpirTargetFieldStorageClass[sizeOfActualPool] ;
5708 0 : unsigned long storageClassIndex = SgUpirTargetField::initializeStorageClassArray (SgUpirTargetFieldStorageArray); ;
5709 0 : assert ( storageClassIndex == sizeOfActualPool );
5710 : }
5711 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOpenclAccessModeModifier ) ;
5712 0 : std::cout << " SgOpenclAccessModeModifier has size " << sizeOfActualPool << std::endl;
5713 0 : SgOpenclAccessModeModifierStorageClass* SgOpenclAccessModeModifierStorageArray = NULL;
5714 0 : if ( 0 < sizeOfActualPool )
5715 : {
5716 0 : SgOpenclAccessModeModifierStorageArray = new SgOpenclAccessModeModifierStorageClass[sizeOfActualPool] ;
5717 0 : unsigned long storageClassIndex = SgOpenclAccessModeModifier::initializeStorageClassArray (SgOpenclAccessModeModifierStorageArray); ;
5718 0 : assert ( storageClassIndex == sizeOfActualPool );
5719 : }
5720 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOpenStatement ) ;
5721 0 : std::cout << " SgOpenStatement has size " << sizeOfActualPool << std::endl;
5722 0 : SgOpenStatementStorageClass* SgOpenStatementStorageArray = NULL;
5723 0 : if ( 0 < sizeOfActualPool )
5724 : {
5725 0 : SgOpenStatementStorageArray = new SgOpenStatementStorageClass[sizeOfActualPool] ;
5726 0 : unsigned long storageClassIndex = SgOpenStatement::initializeStorageClassArray (SgOpenStatementStorageArray); ;
5727 0 : assert ( storageClassIndex == sizeOfActualPool );
5728 : }
5729 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOptions ) ;
5730 0 : std::cout << " SgOptions has size " << sizeOfActualPool << std::endl;
5731 0 : SgOptionsStorageClass* SgOptionsStorageArray = NULL;
5732 0 : if ( 0 < sizeOfActualPool )
5733 : {
5734 0 : SgOptionsStorageArray = new SgOptionsStorageClass[sizeOfActualPool] ;
5735 0 : unsigned long storageClassIndex = SgOptions::initializeStorageClassArray (SgOptionsStorageArray); ;
5736 0 : assert ( storageClassIndex == sizeOfActualPool );
5737 : }
5738 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgOrOp ) ;
5739 0 : std::cout << " SgOrOp has size " << sizeOfActualPool << std::endl;
5740 0 : SgOrOpStorageClass* SgOrOpStorageArray = NULL;
5741 0 : if ( 0 < sizeOfActualPool )
5742 : {
5743 0 : SgOrOpStorageArray = new SgOrOpStorageClass[sizeOfActualPool] ;
5744 0 : unsigned long storageClassIndex = SgOrOp::initializeStorageClassArray (SgOrOpStorageArray); ;
5745 0 : assert ( storageClassIndex == sizeOfActualPool );
5746 : }
5747 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgParameterStatement ) ;
5748 0 : std::cout << " SgParameterStatement has size " << sizeOfActualPool << std::endl;
5749 0 : SgParameterStatementStorageClass* SgParameterStatementStorageArray = NULL;
5750 0 : if ( 0 < sizeOfActualPool )
5751 : {
5752 0 : SgParameterStatementStorageArray = new SgParameterStatementStorageClass[sizeOfActualPool] ;
5753 0 : unsigned long storageClassIndex = SgParameterStatement::initializeStorageClassArray (SgParameterStatementStorageArray); ;
5754 0 : assert ( storageClassIndex == sizeOfActualPool );
5755 : }
5756 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPartialFunctionModifierType ) ;
5757 0 : std::cout << " SgPartialFunctionModifierType has size " << sizeOfActualPool << std::endl;
5758 0 : SgPartialFunctionModifierTypeStorageClass* SgPartialFunctionModifierTypeStorageArray = NULL;
5759 0 : if ( 0 < sizeOfActualPool )
5760 : {
5761 0 : SgPartialFunctionModifierTypeStorageArray = new SgPartialFunctionModifierTypeStorageClass[sizeOfActualPool] ;
5762 0 : unsigned long storageClassIndex = SgPartialFunctionModifierType::initializeStorageClassArray (SgPartialFunctionModifierTypeStorageArray); ;
5763 0 : assert ( storageClassIndex == sizeOfActualPool );
5764 : }
5765 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPartialFunctionType ) ;
5766 0 : std::cout << " SgPartialFunctionType has size " << sizeOfActualPool << std::endl;
5767 0 : SgPartialFunctionTypeStorageClass* SgPartialFunctionTypeStorageArray = NULL;
5768 0 : if ( 0 < sizeOfActualPool )
5769 : {
5770 0 : SgPartialFunctionTypeStorageArray = new SgPartialFunctionTypeStorageClass[sizeOfActualPool] ;
5771 0 : unsigned long storageClassIndex = SgPartialFunctionType::initializeStorageClassArray (SgPartialFunctionTypeStorageArray); ;
5772 0 : assert ( storageClassIndex == sizeOfActualPool );
5773 : }
5774 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPassStatement ) ;
5775 0 : std::cout << " SgPassStatement has size " << sizeOfActualPool << std::endl;
5776 0 : SgPassStatementStorageClass* SgPassStatementStorageArray = NULL;
5777 0 : if ( 0 < sizeOfActualPool )
5778 : {
5779 0 : SgPassStatementStorageArray = new SgPassStatementStorageClass[sizeOfActualPool] ;
5780 0 : unsigned long storageClassIndex = SgPassStatement::initializeStorageClassArray (SgPassStatementStorageArray); ;
5781 0 : assert ( storageClassIndex == sizeOfActualPool );
5782 : }
5783 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPlusAssignOp ) ;
5784 0 : std::cout << " SgPlusAssignOp has size " << sizeOfActualPool << std::endl;
5785 0 : SgPlusAssignOpStorageClass* SgPlusAssignOpStorageArray = NULL;
5786 0 : if ( 0 < sizeOfActualPool )
5787 : {
5788 0 : SgPlusAssignOpStorageArray = new SgPlusAssignOpStorageClass[sizeOfActualPool] ;
5789 0 : unsigned long storageClassIndex = SgPlusAssignOp::initializeStorageClassArray (SgPlusAssignOpStorageArray); ;
5790 0 : assert ( storageClassIndex == sizeOfActualPool );
5791 : }
5792 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPlusPlusOp ) ;
5793 0 : std::cout << " SgPlusPlusOp has size " << sizeOfActualPool << std::endl;
5794 0 : SgPlusPlusOpStorageClass* SgPlusPlusOpStorageArray = NULL;
5795 0 : if ( 0 < sizeOfActualPool )
5796 : {
5797 0 : SgPlusPlusOpStorageArray = new SgPlusPlusOpStorageClass[sizeOfActualPool] ;
5798 0 : unsigned long storageClassIndex = SgPlusPlusOp::initializeStorageClassArray (SgPlusPlusOpStorageArray); ;
5799 0 : assert ( storageClassIndex == sizeOfActualPool );
5800 : }
5801 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPntrArrRefExp ) ;
5802 0 : std::cout << " SgPntrArrRefExp has size " << sizeOfActualPool << std::endl;
5803 0 : SgPntrArrRefExpStorageClass* SgPntrArrRefExpStorageArray = NULL;
5804 0 : if ( 0 < sizeOfActualPool )
5805 : {
5806 0 : SgPntrArrRefExpStorageArray = new SgPntrArrRefExpStorageClass[sizeOfActualPool] ;
5807 0 : unsigned long storageClassIndex = SgPntrArrRefExp::initializeStorageClassArray (SgPntrArrRefExpStorageArray); ;
5808 0 : assert ( storageClassIndex == sizeOfActualPool );
5809 : }
5810 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPointerAssignOp ) ;
5811 0 : std::cout << " SgPointerAssignOp has size " << sizeOfActualPool << std::endl;
5812 0 : SgPointerAssignOpStorageClass* SgPointerAssignOpStorageArray = NULL;
5813 0 : if ( 0 < sizeOfActualPool )
5814 : {
5815 0 : SgPointerAssignOpStorageArray = new SgPointerAssignOpStorageClass[sizeOfActualPool] ;
5816 0 : unsigned long storageClassIndex = SgPointerAssignOp::initializeStorageClassArray (SgPointerAssignOpStorageArray); ;
5817 0 : assert ( storageClassIndex == sizeOfActualPool );
5818 : }
5819 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPointerDerefExp ) ;
5820 0 : std::cout << " SgPointerDerefExp has size " << sizeOfActualPool << std::endl;
5821 0 : SgPointerDerefExpStorageClass* SgPointerDerefExpStorageArray = NULL;
5822 0 : if ( 0 < sizeOfActualPool )
5823 : {
5824 0 : SgPointerDerefExpStorageArray = new SgPointerDerefExpStorageClass[sizeOfActualPool] ;
5825 0 : unsigned long storageClassIndex = SgPointerDerefExp::initializeStorageClassArray (SgPointerDerefExpStorageArray); ;
5826 0 : assert ( storageClassIndex == sizeOfActualPool );
5827 : }
5828 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPointerMemberType ) ;
5829 0 : std::cout << " SgPointerMemberType has size " << sizeOfActualPool << std::endl;
5830 0 : SgPointerMemberTypeStorageClass* SgPointerMemberTypeStorageArray = NULL;
5831 0 : if ( 0 < sizeOfActualPool )
5832 : {
5833 0 : SgPointerMemberTypeStorageArray = new SgPointerMemberTypeStorageClass[sizeOfActualPool] ;
5834 0 : unsigned long storageClassIndex = SgPointerMemberType::initializeStorageClassArray (SgPointerMemberTypeStorageArray); ;
5835 0 : assert ( storageClassIndex == sizeOfActualPool );
5836 : }
5837 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPointerType ) ;
5838 0 : std::cout << " SgPointerType has size " << sizeOfActualPool << std::endl;
5839 0 : SgPointerTypeStorageClass* SgPointerTypeStorageArray = NULL;
5840 0 : if ( 0 < sizeOfActualPool )
5841 : {
5842 0 : SgPointerTypeStorageArray = new SgPointerTypeStorageClass[sizeOfActualPool] ;
5843 0 : unsigned long storageClassIndex = SgPointerType::initializeStorageClassArray (SgPointerTypeStorageArray); ;
5844 0 : assert ( storageClassIndex == sizeOfActualPool );
5845 : }
5846 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPowerOp ) ;
5847 0 : std::cout << " SgPowerOp has size " << sizeOfActualPool << std::endl;
5848 0 : SgPowerOpStorageClass* SgPowerOpStorageArray = NULL;
5849 0 : if ( 0 < sizeOfActualPool )
5850 : {
5851 0 : SgPowerOpStorageArray = new SgPowerOpStorageClass[sizeOfActualPool] ;
5852 0 : unsigned long storageClassIndex = SgPowerOp::initializeStorageClassArray (SgPowerOpStorageArray); ;
5853 0 : assert ( storageClassIndex == sizeOfActualPool );
5854 : }
5855 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPragma ) ;
5856 0 : std::cout << " SgPragma has size " << sizeOfActualPool << std::endl;
5857 0 : SgPragmaStorageClass* SgPragmaStorageArray = NULL;
5858 0 : if ( 0 < sizeOfActualPool )
5859 : {
5860 0 : SgPragmaStorageArray = new SgPragmaStorageClass[sizeOfActualPool] ;
5861 0 : unsigned long storageClassIndex = SgPragma::initializeStorageClassArray (SgPragmaStorageArray); ;
5862 0 : assert ( storageClassIndex == sizeOfActualPool );
5863 : }
5864 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPragmaDeclaration ) ;
5865 0 : std::cout << " SgPragmaDeclaration has size " << sizeOfActualPool << std::endl;
5866 0 : SgPragmaDeclarationStorageClass* SgPragmaDeclarationStorageArray = NULL;
5867 0 : if ( 0 < sizeOfActualPool )
5868 : {
5869 0 : SgPragmaDeclarationStorageArray = new SgPragmaDeclarationStorageClass[sizeOfActualPool] ;
5870 0 : unsigned long storageClassIndex = SgPragmaDeclaration::initializeStorageClassArray (SgPragmaDeclarationStorageArray); ;
5871 0 : assert ( storageClassIndex == sizeOfActualPool );
5872 : }
5873 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPrintStatement ) ;
5874 0 : std::cout << " SgPrintStatement has size " << sizeOfActualPool << std::endl;
5875 0 : SgPrintStatementStorageClass* SgPrintStatementStorageArray = NULL;
5876 0 : if ( 0 < sizeOfActualPool )
5877 : {
5878 0 : SgPrintStatementStorageArray = new SgPrintStatementStorageClass[sizeOfActualPool] ;
5879 0 : unsigned long storageClassIndex = SgPrintStatement::initializeStorageClassArray (SgPrintStatementStorageArray); ;
5880 0 : assert ( storageClassIndex == sizeOfActualPool );
5881 : }
5882 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgProcedureHeaderStatement ) ;
5883 0 : std::cout << " SgProcedureHeaderStatement has size " << sizeOfActualPool << std::endl;
5884 0 : SgProcedureHeaderStatementStorageClass* SgProcedureHeaderStatementStorageArray = NULL;
5885 0 : if ( 0 < sizeOfActualPool )
5886 : {
5887 0 : SgProcedureHeaderStatementStorageArray = new SgProcedureHeaderStatementStorageClass[sizeOfActualPool] ;
5888 0 : unsigned long storageClassIndex = SgProcedureHeaderStatement::initializeStorageClassArray (SgProcedureHeaderStatementStorageArray); ;
5889 0 : assert ( storageClassIndex == sizeOfActualPool );
5890 : }
5891 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgProgramHeaderStatement ) ;
5892 0 : std::cout << " SgProgramHeaderStatement has size " << sizeOfActualPool << std::endl;
5893 0 : SgProgramHeaderStatementStorageClass* SgProgramHeaderStatementStorageArray = NULL;
5894 0 : if ( 0 < sizeOfActualPool )
5895 : {
5896 0 : SgProgramHeaderStatementStorageArray = new SgProgramHeaderStatementStorageClass[sizeOfActualPool] ;
5897 0 : unsigned long storageClassIndex = SgProgramHeaderStatement::initializeStorageClassArray (SgProgramHeaderStatementStorageArray); ;
5898 0 : assert ( storageClassIndex == sizeOfActualPool );
5899 : }
5900 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgProject ) ;
5901 0 : std::cout << " SgProject has size " << sizeOfActualPool << std::endl;
5902 0 : SgProjectStorageClass* SgProjectStorageArray = NULL;
5903 0 : if ( 0 < sizeOfActualPool )
5904 : {
5905 0 : SgProjectStorageArray = new SgProjectStorageClass[sizeOfActualPool] ;
5906 0 : unsigned long storageClassIndex = SgProject::initializeStorageClassArray (SgProjectStorageArray); ;
5907 0 : assert ( storageClassIndex == sizeOfActualPool );
5908 : }
5909 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgPseudoDestructorRefExp ) ;
5910 0 : std::cout << " SgPseudoDestructorRefExp has size " << sizeOfActualPool << std::endl;
5911 0 : SgPseudoDestructorRefExpStorageClass* SgPseudoDestructorRefExpStorageArray = NULL;
5912 0 : if ( 0 < sizeOfActualPool )
5913 : {
5914 0 : SgPseudoDestructorRefExpStorageArray = new SgPseudoDestructorRefExpStorageClass[sizeOfActualPool] ;
5915 0 : unsigned long storageClassIndex = SgPseudoDestructorRefExp::initializeStorageClassArray (SgPseudoDestructorRefExpStorageArray); ;
5916 0 : assert ( storageClassIndex == sizeOfActualPool );
5917 : }
5918 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgQualifiedName ) ;
5919 0 : std::cout << " SgQualifiedName has size " << sizeOfActualPool << std::endl;
5920 0 : SgQualifiedNameStorageClass* SgQualifiedNameStorageArray = NULL;
5921 0 : if ( 0 < sizeOfActualPool )
5922 : {
5923 0 : SgQualifiedNameStorageArray = new SgQualifiedNameStorageClass[sizeOfActualPool] ;
5924 0 : unsigned long storageClassIndex = SgQualifiedName::initializeStorageClassArray (SgQualifiedNameStorageArray); ;
5925 0 : assert ( storageClassIndex == sizeOfActualPool );
5926 : }
5927 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgQualifiedNameType ) ;
5928 0 : std::cout << " SgQualifiedNameType has size " << sizeOfActualPool << std::endl;
5929 0 : SgQualifiedNameTypeStorageClass* SgQualifiedNameTypeStorageArray = NULL;
5930 0 : if ( 0 < sizeOfActualPool )
5931 : {
5932 0 : SgQualifiedNameTypeStorageArray = new SgQualifiedNameTypeStorageClass[sizeOfActualPool] ;
5933 0 : unsigned long storageClassIndex = SgQualifiedNameType::initializeStorageClassArray (SgQualifiedNameTypeStorageArray); ;
5934 0 : assert ( storageClassIndex == sizeOfActualPool );
5935 : }
5936 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRangeExp ) ;
5937 0 : std::cout << " SgRangeExp has size " << sizeOfActualPool << std::endl;
5938 0 : SgRangeExpStorageClass* SgRangeExpStorageArray = NULL;
5939 0 : if ( 0 < sizeOfActualPool )
5940 : {
5941 0 : SgRangeExpStorageArray = new SgRangeExpStorageClass[sizeOfActualPool] ;
5942 0 : unsigned long storageClassIndex = SgRangeExp::initializeStorageClassArray (SgRangeExpStorageArray); ;
5943 0 : assert ( storageClassIndex == sizeOfActualPool );
5944 : }
5945 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRangeBasedForStatement ) ;
5946 0 : std::cout << " SgRangeBasedForStatement has size " << sizeOfActualPool << std::endl;
5947 0 : SgRangeBasedForStatementStorageClass* SgRangeBasedForStatementStorageArray = NULL;
5948 0 : if ( 0 < sizeOfActualPool )
5949 : {
5950 0 : SgRangeBasedForStatementStorageArray = new SgRangeBasedForStatementStorageClass[sizeOfActualPool] ;
5951 0 : unsigned long storageClassIndex = SgRangeBasedForStatement::initializeStorageClassArray (SgRangeBasedForStatementStorageArray); ;
5952 0 : assert ( storageClassIndex == sizeOfActualPool );
5953 : }
5954 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgReadStatement ) ;
5955 0 : std::cout << " SgReadStatement has size " << sizeOfActualPool << std::endl;
5956 0 : SgReadStatementStorageClass* SgReadStatementStorageArray = NULL;
5957 0 : if ( 0 < sizeOfActualPool )
5958 : {
5959 0 : SgReadStatementStorageArray = new SgReadStatementStorageClass[sizeOfActualPool] ;
5960 0 : unsigned long storageClassIndex = SgReadStatement::initializeStorageClassArray (SgReadStatementStorageArray); ;
5961 0 : assert ( storageClassIndex == sizeOfActualPool );
5962 : }
5963 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRealPartOp ) ;
5964 0 : std::cout << " SgRealPartOp has size " << sizeOfActualPool << std::endl;
5965 0 : SgRealPartOpStorageClass* SgRealPartOpStorageArray = NULL;
5966 0 : if ( 0 < sizeOfActualPool )
5967 : {
5968 0 : SgRealPartOpStorageArray = new SgRealPartOpStorageClass[sizeOfActualPool] ;
5969 0 : unsigned long storageClassIndex = SgRealPartOp::initializeStorageClassArray (SgRealPartOpStorageArray); ;
5970 0 : assert ( storageClassIndex == sizeOfActualPool );
5971 : }
5972 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRefExp ) ;
5973 0 : std::cout << " SgRefExp has size " << sizeOfActualPool << std::endl;
5974 0 : SgRefExpStorageClass* SgRefExpStorageArray = NULL;
5975 0 : if ( 0 < sizeOfActualPool )
5976 : {
5977 0 : SgRefExpStorageArray = new SgRefExpStorageClass[sizeOfActualPool] ;
5978 0 : unsigned long storageClassIndex = SgRefExp::initializeStorageClassArray (SgRefExpStorageArray); ;
5979 0 : assert ( storageClassIndex == sizeOfActualPool );
5980 : }
5981 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgReferenceType ) ;
5982 0 : std::cout << " SgReferenceType has size " << sizeOfActualPool << std::endl;
5983 0 : SgReferenceTypeStorageClass* SgReferenceTypeStorageArray = NULL;
5984 0 : if ( 0 < sizeOfActualPool )
5985 : {
5986 0 : SgReferenceTypeStorageArray = new SgReferenceTypeStorageClass[sizeOfActualPool] ;
5987 0 : unsigned long storageClassIndex = SgReferenceType::initializeStorageClassArray (SgReferenceTypeStorageArray); ;
5988 0 : assert ( storageClassIndex == sizeOfActualPool );
5989 : }
5990 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRenamePair ) ;
5991 0 : std::cout << " SgRenamePair has size " << sizeOfActualPool << std::endl;
5992 0 : SgRenamePairStorageClass* SgRenamePairStorageArray = NULL;
5993 0 : if ( 0 < sizeOfActualPool )
5994 : {
5995 0 : SgRenamePairStorageArray = new SgRenamePairStorageClass[sizeOfActualPool] ;
5996 0 : unsigned long storageClassIndex = SgRenamePair::initializeStorageClassArray (SgRenamePairStorageArray); ;
5997 0 : assert ( storageClassIndex == sizeOfActualPool );
5998 : }
5999 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRenameSymbol ) ;
6000 0 : std::cout << " SgRenameSymbol has size " << sizeOfActualPool << std::endl;
6001 0 : SgRenameSymbolStorageClass* SgRenameSymbolStorageArray = NULL;
6002 0 : if ( 0 < sizeOfActualPool )
6003 : {
6004 0 : SgRenameSymbolStorageArray = new SgRenameSymbolStorageClass[sizeOfActualPool] ;
6005 0 : unsigned long storageClassIndex = SgRenameSymbol::initializeStorageClassArray (SgRenameSymbolStorageArray); ;
6006 0 : assert ( storageClassIndex == sizeOfActualPool );
6007 : }
6008 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgReturnStmt ) ;
6009 0 : std::cout << " SgReturnStmt has size " << sizeOfActualPool << std::endl;
6010 0 : SgReturnStmtStorageClass* SgReturnStmtStorageArray = NULL;
6011 0 : if ( 0 < sizeOfActualPool )
6012 : {
6013 0 : SgReturnStmtStorageArray = new SgReturnStmtStorageClass[sizeOfActualPool] ;
6014 0 : unsigned long storageClassIndex = SgReturnStmt::initializeStorageClassArray (SgReturnStmtStorageArray); ;
6015 0 : assert ( storageClassIndex == sizeOfActualPool );
6016 : }
6017 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRewindStatement ) ;
6018 0 : std::cout << " SgRewindStatement has size " << sizeOfActualPool << std::endl;
6019 0 : SgRewindStatementStorageClass* SgRewindStatementStorageArray = NULL;
6020 0 : if ( 0 < sizeOfActualPool )
6021 : {
6022 0 : SgRewindStatementStorageArray = new SgRewindStatementStorageClass[sizeOfActualPool] ;
6023 0 : unsigned long storageClassIndex = SgRewindStatement::initializeStorageClassArray (SgRewindStatementStorageArray); ;
6024 0 : assert ( storageClassIndex == sizeOfActualPool );
6025 : }
6026 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRshiftAssignOp ) ;
6027 0 : std::cout << " SgRshiftAssignOp has size " << sizeOfActualPool << std::endl;
6028 0 : SgRshiftAssignOpStorageClass* SgRshiftAssignOpStorageArray = NULL;
6029 0 : if ( 0 < sizeOfActualPool )
6030 : {
6031 0 : SgRshiftAssignOpStorageArray = new SgRshiftAssignOpStorageClass[sizeOfActualPool] ;
6032 0 : unsigned long storageClassIndex = SgRshiftAssignOp::initializeStorageClassArray (SgRshiftAssignOpStorageArray); ;
6033 0 : assert ( storageClassIndex == sizeOfActualPool );
6034 : }
6035 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRshiftOp ) ;
6036 0 : std::cout << " SgRshiftOp has size " << sizeOfActualPool << std::endl;
6037 0 : SgRshiftOpStorageClass* SgRshiftOpStorageArray = NULL;
6038 0 : if ( 0 < sizeOfActualPool )
6039 : {
6040 0 : SgRshiftOpStorageArray = new SgRshiftOpStorageClass[sizeOfActualPool] ;
6041 0 : unsigned long storageClassIndex = SgRshiftOp::initializeStorageClassArray (SgRshiftOpStorageArray); ;
6042 0 : assert ( storageClassIndex == sizeOfActualPool );
6043 : }
6044 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgRvalueReferenceType ) ;
6045 0 : std::cout << " SgRvalueReferenceType has size " << sizeOfActualPool << std::endl;
6046 0 : SgRvalueReferenceTypeStorageClass* SgRvalueReferenceTypeStorageArray = NULL;
6047 0 : if ( 0 < sizeOfActualPool )
6048 : {
6049 0 : SgRvalueReferenceTypeStorageArray = new SgRvalueReferenceTypeStorageClass[sizeOfActualPool] ;
6050 0 : unsigned long storageClassIndex = SgRvalueReferenceType::initializeStorageClassArray (SgRvalueReferenceTypeStorageArray); ;
6051 0 : assert ( storageClassIndex == sizeOfActualPool );
6052 : }
6053 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgScopeOp ) ;
6054 0 : std::cout << " SgScopeOp has size " << sizeOfActualPool << std::endl;
6055 0 : SgScopeOpStorageClass* SgScopeOpStorageArray = NULL;
6056 0 : if ( 0 < sizeOfActualPool )
6057 : {
6058 0 : SgScopeOpStorageArray = new SgScopeOpStorageClass[sizeOfActualPool] ;
6059 0 : unsigned long storageClassIndex = SgScopeOp::initializeStorageClassArray (SgScopeOpStorageArray); ;
6060 0 : assert ( storageClassIndex == sizeOfActualPool );
6061 : }
6062 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgScopeStatement ) ;
6063 0 : std::cout << " SgScopeStatement has size " << sizeOfActualPool << std::endl;
6064 0 : SgScopeStatementStorageClass* SgScopeStatementStorageArray = NULL;
6065 0 : if ( 0 < sizeOfActualPool )
6066 : {
6067 0 : SgScopeStatementStorageArray = new SgScopeStatementStorageClass[sizeOfActualPool] ;
6068 0 : unsigned long storageClassIndex = SgScopeStatement::initializeStorageClassArray (SgScopeStatementStorageArray); ;
6069 0 : assert ( storageClassIndex == sizeOfActualPool );
6070 : }
6071 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSequenceStatement ) ;
6072 0 : std::cout << " SgSequenceStatement has size " << sizeOfActualPool << std::endl;
6073 0 : SgSequenceStatementStorageClass* SgSequenceStatementStorageArray = NULL;
6074 0 : if ( 0 < sizeOfActualPool )
6075 : {
6076 0 : SgSequenceStatementStorageArray = new SgSequenceStatementStorageClass[sizeOfActualPool] ;
6077 0 : unsigned long storageClassIndex = SgSequenceStatement::initializeStorageClassArray (SgSequenceStatementStorageArray); ;
6078 0 : assert ( storageClassIndex == sizeOfActualPool );
6079 : }
6080 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSetComprehension ) ;
6081 0 : std::cout << " SgSetComprehension has size " << sizeOfActualPool << std::endl;
6082 0 : SgSetComprehensionStorageClass* SgSetComprehensionStorageArray = NULL;
6083 0 : if ( 0 < sizeOfActualPool )
6084 : {
6085 0 : SgSetComprehensionStorageArray = new SgSetComprehensionStorageClass[sizeOfActualPool] ;
6086 0 : unsigned long storageClassIndex = SgSetComprehension::initializeStorageClassArray (SgSetComprehensionStorageArray); ;
6087 0 : assert ( storageClassIndex == sizeOfActualPool );
6088 : }
6089 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgShortVal ) ;
6090 0 : std::cout << " SgShortVal has size " << sizeOfActualPool << std::endl;
6091 0 : SgShortValStorageClass* SgShortValStorageArray = NULL;
6092 0 : if ( 0 < sizeOfActualPool )
6093 : {
6094 0 : SgShortValStorageArray = new SgShortValStorageClass[sizeOfActualPool] ;
6095 0 : unsigned long storageClassIndex = SgShortVal::initializeStorageClassArray (SgShortValStorageArray); ;
6096 0 : assert ( storageClassIndex == sizeOfActualPool );
6097 : }
6098 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDBinaryOp ) ;
6099 0 : std::cout << " SgSIMDBinaryOp has size " << sizeOfActualPool << std::endl;
6100 0 : SgSIMDBinaryOpStorageClass* SgSIMDBinaryOpStorageArray = NULL;
6101 0 : if ( 0 < sizeOfActualPool )
6102 : {
6103 0 : SgSIMDBinaryOpStorageArray = new SgSIMDBinaryOpStorageClass[sizeOfActualPool] ;
6104 0 : unsigned long storageClassIndex = SgSIMDBinaryOp::initializeStorageClassArray (SgSIMDBinaryOpStorageArray); ;
6105 0 : assert ( storageClassIndex == sizeOfActualPool );
6106 : }
6107 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDAddOp ) ;
6108 0 : std::cout << " SgSIMDAddOp has size " << sizeOfActualPool << std::endl;
6109 0 : SgSIMDAddOpStorageClass* SgSIMDAddOpStorageArray = NULL;
6110 0 : if ( 0 < sizeOfActualPool )
6111 : {
6112 0 : SgSIMDAddOpStorageArray = new SgSIMDAddOpStorageClass[sizeOfActualPool] ;
6113 0 : unsigned long storageClassIndex = SgSIMDAddOp::initializeStorageClassArray (SgSIMDAddOpStorageArray); ;
6114 0 : assert ( storageClassIndex == sizeOfActualPool );
6115 : }
6116 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDSubOp ) ;
6117 0 : std::cout << " SgSIMDSubOp has size " << sizeOfActualPool << std::endl;
6118 0 : SgSIMDSubOpStorageClass* SgSIMDSubOpStorageArray = NULL;
6119 0 : if ( 0 < sizeOfActualPool )
6120 : {
6121 0 : SgSIMDSubOpStorageArray = new SgSIMDSubOpStorageClass[sizeOfActualPool] ;
6122 0 : unsigned long storageClassIndex = SgSIMDSubOp::initializeStorageClassArray (SgSIMDSubOpStorageArray); ;
6123 0 : assert ( storageClassIndex == sizeOfActualPool );
6124 : }
6125 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDMulOp ) ;
6126 0 : std::cout << " SgSIMDMulOp has size " << sizeOfActualPool << std::endl;
6127 0 : SgSIMDMulOpStorageClass* SgSIMDMulOpStorageArray = NULL;
6128 0 : if ( 0 < sizeOfActualPool )
6129 : {
6130 0 : SgSIMDMulOpStorageArray = new SgSIMDMulOpStorageClass[sizeOfActualPool] ;
6131 0 : unsigned long storageClassIndex = SgSIMDMulOp::initializeStorageClassArray (SgSIMDMulOpStorageArray); ;
6132 0 : assert ( storageClassIndex == sizeOfActualPool );
6133 : }
6134 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDDivOp ) ;
6135 0 : std::cout << " SgSIMDDivOp has size " << sizeOfActualPool << std::endl;
6136 0 : SgSIMDDivOpStorageClass* SgSIMDDivOpStorageArray = NULL;
6137 0 : if ( 0 < sizeOfActualPool )
6138 : {
6139 0 : SgSIMDDivOpStorageArray = new SgSIMDDivOpStorageClass[sizeOfActualPool] ;
6140 0 : unsigned long storageClassIndex = SgSIMDDivOp::initializeStorageClassArray (SgSIMDDivOpStorageArray); ;
6141 0 : assert ( storageClassIndex == sizeOfActualPool );
6142 : }
6143 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDFmaOp ) ;
6144 0 : std::cout << " SgSIMDFmaOp has size " << sizeOfActualPool << std::endl;
6145 0 : SgSIMDFmaOpStorageClass* SgSIMDFmaOpStorageArray = NULL;
6146 0 : if ( 0 < sizeOfActualPool )
6147 : {
6148 0 : SgSIMDFmaOpStorageArray = new SgSIMDFmaOpStorageClass[sizeOfActualPool] ;
6149 0 : unsigned long storageClassIndex = SgSIMDFmaOp::initializeStorageClassArray (SgSIMDFmaOpStorageArray); ;
6150 0 : assert ( storageClassIndex == sizeOfActualPool );
6151 : }
6152 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDLoad ) ;
6153 0 : std::cout << " SgSIMDLoad has size " << sizeOfActualPool << std::endl;
6154 0 : SgSIMDLoadStorageClass* SgSIMDLoadStorageArray = NULL;
6155 0 : if ( 0 < sizeOfActualPool )
6156 : {
6157 0 : SgSIMDLoadStorageArray = new SgSIMDLoadStorageClass[sizeOfActualPool] ;
6158 0 : unsigned long storageClassIndex = SgSIMDLoad::initializeStorageClassArray (SgSIMDLoadStorageArray); ;
6159 0 : assert ( storageClassIndex == sizeOfActualPool );
6160 : }
6161 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDBroadcast ) ;
6162 0 : std::cout << " SgSIMDBroadcast has size " << sizeOfActualPool << std::endl;
6163 0 : SgSIMDBroadcastStorageClass* SgSIMDBroadcastStorageArray = NULL;
6164 0 : if ( 0 < sizeOfActualPool )
6165 : {
6166 0 : SgSIMDBroadcastStorageArray = new SgSIMDBroadcastStorageClass[sizeOfActualPool] ;
6167 0 : unsigned long storageClassIndex = SgSIMDBroadcast::initializeStorageClassArray (SgSIMDBroadcastStorageArray); ;
6168 0 : assert ( storageClassIndex == sizeOfActualPool );
6169 : }
6170 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDStore ) ;
6171 0 : std::cout << " SgSIMDStore has size " << sizeOfActualPool << std::endl;
6172 0 : SgSIMDStoreStorageClass* SgSIMDStoreStorageArray = NULL;
6173 0 : if ( 0 < sizeOfActualPool )
6174 : {
6175 0 : SgSIMDStoreStorageArray = new SgSIMDStoreStorageClass[sizeOfActualPool] ;
6176 0 : unsigned long storageClassIndex = SgSIMDStore::initializeStorageClassArray (SgSIMDStoreStorageArray); ;
6177 0 : assert ( storageClassIndex == sizeOfActualPool );
6178 : }
6179 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDPartialStore ) ;
6180 0 : std::cout << " SgSIMDPartialStore has size " << sizeOfActualPool << std::endl;
6181 0 : SgSIMDPartialStoreStorageClass* SgSIMDPartialStoreStorageArray = NULL;
6182 0 : if ( 0 < sizeOfActualPool )
6183 : {
6184 0 : SgSIMDPartialStoreStorageArray = new SgSIMDPartialStoreStorageClass[sizeOfActualPool] ;
6185 0 : unsigned long storageClassIndex = SgSIMDPartialStore::initializeStorageClassArray (SgSIMDPartialStoreStorageArray); ;
6186 0 : assert ( storageClassIndex == sizeOfActualPool );
6187 : }
6188 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDScalarStore ) ;
6189 0 : std::cout << " SgSIMDScalarStore has size " << sizeOfActualPool << std::endl;
6190 0 : SgSIMDScalarStoreStorageClass* SgSIMDScalarStoreStorageArray = NULL;
6191 0 : if ( 0 < sizeOfActualPool )
6192 : {
6193 0 : SgSIMDScalarStoreStorageArray = new SgSIMDScalarStoreStorageClass[sizeOfActualPool] ;
6194 0 : unsigned long storageClassIndex = SgSIMDScalarStore::initializeStorageClassArray (SgSIMDScalarStoreStorageArray); ;
6195 0 : assert ( storageClassIndex == sizeOfActualPool );
6196 : }
6197 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDGather ) ;
6198 0 : std::cout << " SgSIMDGather has size " << sizeOfActualPool << std::endl;
6199 0 : SgSIMDGatherStorageClass* SgSIMDGatherStorageArray = NULL;
6200 0 : if ( 0 < sizeOfActualPool )
6201 : {
6202 0 : SgSIMDGatherStorageArray = new SgSIMDGatherStorageClass[sizeOfActualPool] ;
6203 0 : unsigned long storageClassIndex = SgSIMDGather::initializeStorageClassArray (SgSIMDGatherStorageArray); ;
6204 0 : assert ( storageClassIndex == sizeOfActualPool );
6205 : }
6206 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDExplicitGather ) ;
6207 0 : std::cout << " SgSIMDExplicitGather has size " << sizeOfActualPool << std::endl;
6208 0 : SgSIMDExplicitGatherStorageClass* SgSIMDExplicitGatherStorageArray = NULL;
6209 0 : if ( 0 < sizeOfActualPool )
6210 : {
6211 0 : SgSIMDExplicitGatherStorageArray = new SgSIMDExplicitGatherStorageClass[sizeOfActualPool] ;
6212 0 : unsigned long storageClassIndex = SgSIMDExplicitGather::initializeStorageClassArray (SgSIMDExplicitGatherStorageArray); ;
6213 0 : assert ( storageClassIndex == sizeOfActualPool );
6214 : }
6215 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSIMDScatter ) ;
6216 0 : std::cout << " SgSIMDScatter has size " << sizeOfActualPool << std::endl;
6217 0 : SgSIMDScatterStorageClass* SgSIMDScatterStorageArray = NULL;
6218 0 : if ( 0 < sizeOfActualPool )
6219 : {
6220 0 : SgSIMDScatterStorageArray = new SgSIMDScatterStorageClass[sizeOfActualPool] ;
6221 0 : unsigned long storageClassIndex = SgSIMDScatter::initializeStorageClassArray (SgSIMDScatterStorageArray); ;
6222 0 : assert ( storageClassIndex == sizeOfActualPool );
6223 : }
6224 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSizeOfOp ) ;
6225 0 : std::cout << " SgSizeOfOp has size " << sizeOfActualPool << std::endl;
6226 0 : SgSizeOfOpStorageClass* SgSizeOfOpStorageArray = NULL;
6227 0 : if ( 0 < sizeOfActualPool )
6228 : {
6229 0 : SgSizeOfOpStorageArray = new SgSizeOfOpStorageClass[sizeOfActualPool] ;
6230 0 : unsigned long storageClassIndex = SgSizeOfOp::initializeStorageClassArray (SgSizeOfOpStorageArray); ;
6231 0 : assert ( storageClassIndex == sizeOfActualPool );
6232 : }
6233 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgAlignOfOp ) ;
6234 0 : std::cout << " SgAlignOfOp has size " << sizeOfActualPool << std::endl;
6235 0 : SgAlignOfOpStorageClass* SgAlignOfOpStorageArray = NULL;
6236 0 : if ( 0 < sizeOfActualPool )
6237 : {
6238 0 : SgAlignOfOpStorageArray = new SgAlignOfOpStorageClass[sizeOfActualPool] ;
6239 0 : unsigned long storageClassIndex = SgAlignOfOp::initializeStorageClassArray (SgAlignOfOpStorageArray); ;
6240 0 : assert ( storageClassIndex == sizeOfActualPool );
6241 : }
6242 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSourceFile ) ;
6243 0 : std::cout << " SgSourceFile has size " << sizeOfActualPool << std::endl;
6244 0 : SgSourceFileStorageClass* SgSourceFileStorageArray = NULL;
6245 0 : if ( 0 < sizeOfActualPool )
6246 : {
6247 0 : SgSourceFileStorageArray = new SgSourceFileStorageClass[sizeOfActualPool] ;
6248 0 : unsigned long storageClassIndex = SgSourceFile::initializeStorageClassArray (SgSourceFileStorageArray); ;
6249 0 : assert ( storageClassIndex == sizeOfActualPool );
6250 : }
6251 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSpaceshipOp ) ;
6252 0 : std::cout << " SgSpaceshipOp has size " << sizeOfActualPool << std::endl;
6253 0 : SgSpaceshipOpStorageClass* SgSpaceshipOpStorageArray = NULL;
6254 0 : if ( 0 < sizeOfActualPool )
6255 : {
6256 0 : SgSpaceshipOpStorageArray = new SgSpaceshipOpStorageClass[sizeOfActualPool] ;
6257 0 : unsigned long storageClassIndex = SgSpaceshipOp::initializeStorageClassArray (SgSpaceshipOpStorageArray); ;
6258 0 : assert ( storageClassIndex == sizeOfActualPool );
6259 : }
6260 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSpawnStmt ) ;
6261 0 : std::cout << " SgSpawnStmt has size " << sizeOfActualPool << std::endl;
6262 0 : SgSpawnStmtStorageClass* SgSpawnStmtStorageArray = NULL;
6263 0 : if ( 0 < sizeOfActualPool )
6264 : {
6265 0 : SgSpawnStmtStorageArray = new SgSpawnStmtStorageClass[sizeOfActualPool] ;
6266 0 : unsigned long storageClassIndex = SgSpawnStmt::initializeStorageClassArray (SgSpawnStmtStorageArray); ;
6267 0 : assert ( storageClassIndex == sizeOfActualPool );
6268 : }
6269 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSyncAllStatement ) ;
6270 0 : std::cout << " SgSyncAllStatement has size " << sizeOfActualPool << std::endl;
6271 0 : SgSyncAllStatementStorageClass* SgSyncAllStatementStorageArray = NULL;
6272 0 : if ( 0 < sizeOfActualPool )
6273 : {
6274 0 : SgSyncAllStatementStorageArray = new SgSyncAllStatementStorageClass[sizeOfActualPool] ;
6275 0 : unsigned long storageClassIndex = SgSyncAllStatement::initializeStorageClassArray (SgSyncAllStatementStorageArray); ;
6276 0 : assert ( storageClassIndex == sizeOfActualPool );
6277 : }
6278 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSyncImagesStatement ) ;
6279 0 : std::cout << " SgSyncImagesStatement has size " << sizeOfActualPool << std::endl;
6280 0 : SgSyncImagesStatementStorageClass* SgSyncImagesStatementStorageArray = NULL;
6281 0 : if ( 0 < sizeOfActualPool )
6282 : {
6283 0 : SgSyncImagesStatementStorageArray = new SgSyncImagesStatementStorageClass[sizeOfActualPool] ;
6284 0 : unsigned long storageClassIndex = SgSyncImagesStatement::initializeStorageClassArray (SgSyncImagesStatementStorageArray); ;
6285 0 : assert ( storageClassIndex == sizeOfActualPool );
6286 : }
6287 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSyncMemoryStatement ) ;
6288 0 : std::cout << " SgSyncMemoryStatement has size " << sizeOfActualPool << std::endl;
6289 0 : SgSyncMemoryStatementStorageClass* SgSyncMemoryStatementStorageArray = NULL;
6290 0 : if ( 0 < sizeOfActualPool )
6291 : {
6292 0 : SgSyncMemoryStatementStorageArray = new SgSyncMemoryStatementStorageClass[sizeOfActualPool] ;
6293 0 : unsigned long storageClassIndex = SgSyncMemoryStatement::initializeStorageClassArray (SgSyncMemoryStatementStorageArray); ;
6294 0 : assert ( storageClassIndex == sizeOfActualPool );
6295 : }
6296 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSyncTeamStatement ) ;
6297 0 : std::cout << " SgSyncTeamStatement has size " << sizeOfActualPool << std::endl;
6298 0 : SgSyncTeamStatementStorageClass* SgSyncTeamStatementStorageArray = NULL;
6299 0 : if ( 0 < sizeOfActualPool )
6300 : {
6301 0 : SgSyncTeamStatementStorageArray = new SgSyncTeamStatementStorageClass[sizeOfActualPool] ;
6302 0 : unsigned long storageClassIndex = SgSyncTeamStatement::initializeStorageClassArray (SgSyncTeamStatementStorageArray); ;
6303 0 : assert ( storageClassIndex == sizeOfActualPool );
6304 : }
6305 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgLockStatement ) ;
6306 0 : std::cout << " SgLockStatement has size " << sizeOfActualPool << std::endl;
6307 0 : SgLockStatementStorageClass* SgLockStatementStorageArray = NULL;
6308 0 : if ( 0 < sizeOfActualPool )
6309 : {
6310 0 : SgLockStatementStorageArray = new SgLockStatementStorageClass[sizeOfActualPool] ;
6311 0 : unsigned long storageClassIndex = SgLockStatement::initializeStorageClassArray (SgLockStatementStorageArray); ;
6312 0 : assert ( storageClassIndex == sizeOfActualPool );
6313 : }
6314 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnlockStatement ) ;
6315 0 : std::cout << " SgUnlockStatement has size " << sizeOfActualPool << std::endl;
6316 0 : SgUnlockStatementStorageClass* SgUnlockStatementStorageArray = NULL;
6317 0 : if ( 0 < sizeOfActualPool )
6318 : {
6319 0 : SgUnlockStatementStorageArray = new SgUnlockStatementStorageClass[sizeOfActualPool] ;
6320 0 : unsigned long storageClassIndex = SgUnlockStatement::initializeStorageClassArray (SgUnlockStatementStorageArray); ;
6321 0 : assert ( storageClassIndex == sizeOfActualPool );
6322 : }
6323 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgProcessControlStatement ) ;
6324 0 : std::cout << " SgProcessControlStatement has size " << sizeOfActualPool << std::endl;
6325 0 : SgProcessControlStatementStorageClass* SgProcessControlStatementStorageArray = NULL;
6326 0 : if ( 0 < sizeOfActualPool )
6327 : {
6328 0 : SgProcessControlStatementStorageArray = new SgProcessControlStatementStorageClass[sizeOfActualPool] ;
6329 0 : unsigned long storageClassIndex = SgProcessControlStatement::initializeStorageClassArray (SgProcessControlStatementStorageArray); ;
6330 0 : assert ( storageClassIndex == sizeOfActualPool );
6331 : }
6332 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSpecialFunctionModifier ) ;
6333 0 : std::cout << " SgSpecialFunctionModifier has size " << sizeOfActualPool << std::endl;
6334 0 : SgSpecialFunctionModifierStorageClass* SgSpecialFunctionModifierStorageArray = NULL;
6335 0 : if ( 0 < sizeOfActualPool )
6336 : {
6337 0 : SgSpecialFunctionModifierStorageArray = new SgSpecialFunctionModifierStorageClass[sizeOfActualPool] ;
6338 0 : unsigned long storageClassIndex = SgSpecialFunctionModifier::initializeStorageClassArray (SgSpecialFunctionModifierStorageArray); ;
6339 0 : assert ( storageClassIndex == sizeOfActualPool );
6340 : }
6341 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStatement ) ;
6342 0 : std::cout << " SgStatement has size " << sizeOfActualPool << std::endl;
6343 0 : SgStatementStorageClass* SgStatementStorageArray = NULL;
6344 0 : if ( 0 < sizeOfActualPool )
6345 : {
6346 0 : SgStatementStorageArray = new SgStatementStorageClass[sizeOfActualPool] ;
6347 0 : unsigned long storageClassIndex = SgStatement::initializeStorageClassArray (SgStatementStorageArray); ;
6348 0 : assert ( storageClassIndex == sizeOfActualPool );
6349 : }
6350 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStaticAssertionDeclaration ) ;
6351 0 : std::cout << " SgStaticAssertionDeclaration has size " << sizeOfActualPool << std::endl;
6352 0 : SgStaticAssertionDeclarationStorageClass* SgStaticAssertionDeclarationStorageArray = NULL;
6353 0 : if ( 0 < sizeOfActualPool )
6354 : {
6355 0 : SgStaticAssertionDeclarationStorageArray = new SgStaticAssertionDeclarationStorageClass[sizeOfActualPool] ;
6356 0 : unsigned long storageClassIndex = SgStaticAssertionDeclaration::initializeStorageClassArray (SgStaticAssertionDeclarationStorageArray); ;
6357 0 : assert ( storageClassIndex == sizeOfActualPool );
6358 : }
6359 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStmtDeclarationStatement ) ;
6360 0 : std::cout << " SgStmtDeclarationStatement has size " << sizeOfActualPool << std::endl;
6361 0 : SgStmtDeclarationStatementStorageClass* SgStmtDeclarationStatementStorageArray = NULL;
6362 0 : if ( 0 < sizeOfActualPool )
6363 : {
6364 0 : SgStmtDeclarationStatementStorageArray = new SgStmtDeclarationStatementStorageClass[sizeOfActualPool] ;
6365 0 : unsigned long storageClassIndex = SgStmtDeclarationStatement::initializeStorageClassArray (SgStmtDeclarationStatementStorageArray); ;
6366 0 : assert ( storageClassIndex == sizeOfActualPool );
6367 : }
6368 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStatementExpression ) ;
6369 0 : std::cout << " SgStatementExpression has size " << sizeOfActualPool << std::endl;
6370 0 : SgStatementExpressionStorageClass* SgStatementExpressionStorageArray = NULL;
6371 0 : if ( 0 < sizeOfActualPool )
6372 : {
6373 0 : SgStatementExpressionStorageArray = new SgStatementExpressionStorageClass[sizeOfActualPool] ;
6374 0 : unsigned long storageClassIndex = SgStatementExpression::initializeStorageClassArray (SgStatementExpressionStorageArray); ;
6375 0 : assert ( storageClassIndex == sizeOfActualPool );
6376 : }
6377 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStatementFunctionStatement ) ;
6378 0 : std::cout << " SgStatementFunctionStatement has size " << sizeOfActualPool << std::endl;
6379 0 : SgStatementFunctionStatementStorageClass* SgStatementFunctionStatementStorageArray = NULL;
6380 0 : if ( 0 < sizeOfActualPool )
6381 : {
6382 0 : SgStatementFunctionStatementStorageArray = new SgStatementFunctionStatementStorageClass[sizeOfActualPool] ;
6383 0 : unsigned long storageClassIndex = SgStatementFunctionStatement::initializeStorageClassArray (SgStatementFunctionStatementStorageArray); ;
6384 0 : assert ( storageClassIndex == sizeOfActualPool );
6385 : }
6386 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStorageModifier ) ;
6387 0 : std::cout << " SgStorageModifier has size " << sizeOfActualPool << std::endl;
6388 0 : SgStorageModifierStorageClass* SgStorageModifierStorageArray = NULL;
6389 0 : if ( 0 < sizeOfActualPool )
6390 : {
6391 0 : SgStorageModifierStorageArray = new SgStorageModifierStorageClass[sizeOfActualPool] ;
6392 0 : unsigned long storageClassIndex = SgStorageModifier::initializeStorageClassArray (SgStorageModifierStorageArray); ;
6393 0 : assert ( storageClassIndex == sizeOfActualPool );
6394 : }
6395 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStringConversion ) ;
6396 0 : std::cout << " SgStringConversion has size " << sizeOfActualPool << std::endl;
6397 0 : SgStringConversionStorageClass* SgStringConversionStorageArray = NULL;
6398 0 : if ( 0 < sizeOfActualPool )
6399 : {
6400 0 : SgStringConversionStorageArray = new SgStringConversionStorageClass[sizeOfActualPool] ;
6401 0 : unsigned long storageClassIndex = SgStringConversion::initializeStorageClassArray (SgStringConversionStorageArray); ;
6402 0 : assert ( storageClassIndex == sizeOfActualPool );
6403 : }
6404 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStringKeyedBidirectionalGraph ) ;
6405 0 : std::cout << " SgStringKeyedBidirectionalGraph has size " << sizeOfActualPool << std::endl;
6406 0 : SgStringKeyedBidirectionalGraphStorageClass* SgStringKeyedBidirectionalGraphStorageArray = NULL;
6407 0 : if ( 0 < sizeOfActualPool )
6408 : {
6409 0 : SgStringKeyedBidirectionalGraphStorageArray = new SgStringKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
6410 0 : unsigned long storageClassIndex = SgStringKeyedBidirectionalGraph::initializeStorageClassArray (SgStringKeyedBidirectionalGraphStorageArray); ;
6411 0 : assert ( storageClassIndex == sizeOfActualPool );
6412 : }
6413 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStringVal ) ;
6414 0 : std::cout << " SgStringVal has size " << sizeOfActualPool << std::endl;
6415 0 : SgStringValStorageClass* SgStringValStorageArray = NULL;
6416 0 : if ( 0 < sizeOfActualPool )
6417 : {
6418 0 : SgStringValStorageArray = new SgStringValStorageClass[sizeOfActualPool] ;
6419 0 : unsigned long storageClassIndex = SgStringVal::initializeStorageClassArray (SgStringValStorageArray); ;
6420 0 : assert ( storageClassIndex == sizeOfActualPool );
6421 : }
6422 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgStructureModifier ) ;
6423 0 : std::cout << " SgStructureModifier has size " << sizeOfActualPool << std::endl;
6424 0 : SgStructureModifierStorageClass* SgStructureModifierStorageArray = NULL;
6425 0 : if ( 0 < sizeOfActualPool )
6426 : {
6427 0 : SgStructureModifierStorageArray = new SgStructureModifierStorageClass[sizeOfActualPool] ;
6428 0 : unsigned long storageClassIndex = SgStructureModifier::initializeStorageClassArray (SgStructureModifierStorageArray); ;
6429 0 : assert ( storageClassIndex == sizeOfActualPool );
6430 : }
6431 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSubscriptExpression ) ;
6432 0 : std::cout << " SgSubscriptExpression has size " << sizeOfActualPool << std::endl;
6433 0 : SgSubscriptExpressionStorageClass* SgSubscriptExpressionStorageArray = NULL;
6434 0 : if ( 0 < sizeOfActualPool )
6435 : {
6436 0 : SgSubscriptExpressionStorageArray = new SgSubscriptExpressionStorageClass[sizeOfActualPool] ;
6437 0 : unsigned long storageClassIndex = SgSubscriptExpression::initializeStorageClassArray (SgSubscriptExpressionStorageArray); ;
6438 0 : assert ( storageClassIndex == sizeOfActualPool );
6439 : }
6440 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSubtractOp ) ;
6441 0 : std::cout << " SgSubtractOp has size " << sizeOfActualPool << std::endl;
6442 0 : SgSubtractOpStorageClass* SgSubtractOpStorageArray = NULL;
6443 0 : if ( 0 < sizeOfActualPool )
6444 : {
6445 0 : SgSubtractOpStorageArray = new SgSubtractOpStorageClass[sizeOfActualPool] ;
6446 0 : unsigned long storageClassIndex = SgSubtractOp::initializeStorageClassArray (SgSubtractOpStorageArray); ;
6447 0 : assert ( storageClassIndex == sizeOfActualPool );
6448 : }
6449 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSupport ) ;
6450 0 : std::cout << " SgSupport has size " << sizeOfActualPool << std::endl;
6451 0 : SgSupportStorageClass* SgSupportStorageArray = NULL;
6452 0 : if ( 0 < sizeOfActualPool )
6453 : {
6454 0 : SgSupportStorageArray = new SgSupportStorageClass[sizeOfActualPool] ;
6455 0 : unsigned long storageClassIndex = SgSupport::initializeStorageClassArray (SgSupportStorageArray); ;
6456 0 : assert ( storageClassIndex == sizeOfActualPool );
6457 : }
6458 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSwitchStatement ) ;
6459 0 : std::cout << " SgSwitchStatement has size " << sizeOfActualPool << std::endl;
6460 0 : SgSwitchStatementStorageClass* SgSwitchStatementStorageArray = NULL;
6461 0 : if ( 0 < sizeOfActualPool )
6462 : {
6463 0 : SgSwitchStatementStorageArray = new SgSwitchStatementStorageClass[sizeOfActualPool] ;
6464 0 : unsigned long storageClassIndex = SgSwitchStatement::initializeStorageClassArray (SgSwitchStatementStorageArray); ;
6465 0 : assert ( storageClassIndex == sizeOfActualPool );
6466 : }
6467 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSymbolTable ) ;
6468 0 : std::cout << " SgSymbolTable has size " << sizeOfActualPool << std::endl;
6469 0 : SgSymbolTableStorageClass* SgSymbolTableStorageArray = NULL;
6470 0 : if ( 0 < sizeOfActualPool )
6471 : {
6472 0 : SgSymbolTableStorageArray = new SgSymbolTableStorageClass[sizeOfActualPool] ;
6473 0 : unsigned long storageClassIndex = SgSymbolTable::initializeStorageClassArray (SgSymbolTableStorageArray); ;
6474 0 : assert ( storageClassIndex == sizeOfActualPool );
6475 : }
6476 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateArgument ) ;
6477 0 : std::cout << " SgTemplateArgument has size " << sizeOfActualPool << std::endl;
6478 0 : SgTemplateArgumentStorageClass* SgTemplateArgumentStorageArray = NULL;
6479 0 : if ( 0 < sizeOfActualPool )
6480 : {
6481 0 : SgTemplateArgumentStorageArray = new SgTemplateArgumentStorageClass[sizeOfActualPool] ;
6482 0 : unsigned long storageClassIndex = SgTemplateArgument::initializeStorageClassArray (SgTemplateArgumentStorageArray); ;
6483 0 : assert ( storageClassIndex == sizeOfActualPool );
6484 : }
6485 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateArgumentList ) ;
6486 0 : std::cout << " SgTemplateArgumentList has size " << sizeOfActualPool << std::endl;
6487 0 : SgTemplateArgumentListStorageClass* SgTemplateArgumentListStorageArray = NULL;
6488 0 : if ( 0 < sizeOfActualPool )
6489 : {
6490 0 : SgTemplateArgumentListStorageArray = new SgTemplateArgumentListStorageClass[sizeOfActualPool] ;
6491 0 : unsigned long storageClassIndex = SgTemplateArgumentList::initializeStorageClassArray (SgTemplateArgumentListStorageArray); ;
6492 0 : assert ( storageClassIndex == sizeOfActualPool );
6493 : }
6494 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateDeclaration ) ;
6495 0 : std::cout << " SgTemplateDeclaration has size " << sizeOfActualPool << std::endl;
6496 0 : SgTemplateDeclarationStorageClass* SgTemplateDeclarationStorageArray = NULL;
6497 0 : if ( 0 < sizeOfActualPool )
6498 : {
6499 0 : SgTemplateDeclarationStorageArray = new SgTemplateDeclarationStorageClass[sizeOfActualPool] ;
6500 0 : unsigned long storageClassIndex = SgTemplateDeclaration::initializeStorageClassArray (SgTemplateDeclarationStorageArray); ;
6501 0 : assert ( storageClassIndex == sizeOfActualPool );
6502 : }
6503 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateClassDeclaration ) ;
6504 0 : std::cout << " SgTemplateClassDeclaration has size " << sizeOfActualPool << std::endl;
6505 0 : SgTemplateClassDeclarationStorageClass* SgTemplateClassDeclarationStorageArray = NULL;
6506 0 : if ( 0 < sizeOfActualPool )
6507 : {
6508 0 : SgTemplateClassDeclarationStorageArray = new SgTemplateClassDeclarationStorageClass[sizeOfActualPool] ;
6509 0 : unsigned long storageClassIndex = SgTemplateClassDeclaration::initializeStorageClassArray (SgTemplateClassDeclarationStorageArray); ;
6510 0 : assert ( storageClassIndex == sizeOfActualPool );
6511 : }
6512 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateClassSymbol ) ;
6513 0 : std::cout << " SgTemplateClassSymbol has size " << sizeOfActualPool << std::endl;
6514 0 : SgTemplateClassSymbolStorageClass* SgTemplateClassSymbolStorageArray = NULL;
6515 0 : if ( 0 < sizeOfActualPool )
6516 : {
6517 0 : SgTemplateClassSymbolStorageArray = new SgTemplateClassSymbolStorageClass[sizeOfActualPool] ;
6518 0 : unsigned long storageClassIndex = SgTemplateClassSymbol::initializeStorageClassArray (SgTemplateClassSymbolStorageArray); ;
6519 0 : assert ( storageClassIndex == sizeOfActualPool );
6520 : }
6521 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateFunctionDeclaration ) ;
6522 0 : std::cout << " SgTemplateFunctionDeclaration has size " << sizeOfActualPool << std::endl;
6523 0 : SgTemplateFunctionDeclarationStorageClass* SgTemplateFunctionDeclarationStorageArray = NULL;
6524 0 : if ( 0 < sizeOfActualPool )
6525 : {
6526 0 : SgTemplateFunctionDeclarationStorageArray = new SgTemplateFunctionDeclarationStorageClass[sizeOfActualPool] ;
6527 0 : unsigned long storageClassIndex = SgTemplateFunctionDeclaration::initializeStorageClassArray (SgTemplateFunctionDeclarationStorageArray); ;
6528 0 : assert ( storageClassIndex == sizeOfActualPool );
6529 : }
6530 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateFunctionRefExp ) ;
6531 0 : std::cout << " SgTemplateFunctionRefExp has size " << sizeOfActualPool << std::endl;
6532 0 : SgTemplateFunctionRefExpStorageClass* SgTemplateFunctionRefExpStorageArray = NULL;
6533 0 : if ( 0 < sizeOfActualPool )
6534 : {
6535 0 : SgTemplateFunctionRefExpStorageArray = new SgTemplateFunctionRefExpStorageClass[sizeOfActualPool] ;
6536 0 : unsigned long storageClassIndex = SgTemplateFunctionRefExp::initializeStorageClassArray (SgTemplateFunctionRefExpStorageArray); ;
6537 0 : assert ( storageClassIndex == sizeOfActualPool );
6538 : }
6539 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateFunctionSymbol ) ;
6540 0 : std::cout << " SgTemplateFunctionSymbol has size " << sizeOfActualPool << std::endl;
6541 0 : SgTemplateFunctionSymbolStorageClass* SgTemplateFunctionSymbolStorageArray = NULL;
6542 0 : if ( 0 < sizeOfActualPool )
6543 : {
6544 0 : SgTemplateFunctionSymbolStorageArray = new SgTemplateFunctionSymbolStorageClass[sizeOfActualPool] ;
6545 0 : unsigned long storageClassIndex = SgTemplateFunctionSymbol::initializeStorageClassArray (SgTemplateFunctionSymbolStorageArray); ;
6546 0 : assert ( storageClassIndex == sizeOfActualPool );
6547 : }
6548 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateMemberFunctionDeclaration ) ;
6549 0 : std::cout << " SgTemplateMemberFunctionDeclaration has size " << sizeOfActualPool << std::endl;
6550 0 : SgTemplateMemberFunctionDeclarationStorageClass* SgTemplateMemberFunctionDeclarationStorageArray = NULL;
6551 0 : if ( 0 < sizeOfActualPool )
6552 : {
6553 0 : SgTemplateMemberFunctionDeclarationStorageArray = new SgTemplateMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
6554 0 : unsigned long storageClassIndex = SgTemplateMemberFunctionDeclaration::initializeStorageClassArray (SgTemplateMemberFunctionDeclarationStorageArray); ;
6555 0 : assert ( storageClassIndex == sizeOfActualPool );
6556 : }
6557 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateMemberFunctionRefExp ) ;
6558 0 : std::cout << " SgTemplateMemberFunctionRefExp has size " << sizeOfActualPool << std::endl;
6559 0 : SgTemplateMemberFunctionRefExpStorageClass* SgTemplateMemberFunctionRefExpStorageArray = NULL;
6560 0 : if ( 0 < sizeOfActualPool )
6561 : {
6562 0 : SgTemplateMemberFunctionRefExpStorageArray = new SgTemplateMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
6563 0 : unsigned long storageClassIndex = SgTemplateMemberFunctionRefExp::initializeStorageClassArray (SgTemplateMemberFunctionRefExpStorageArray); ;
6564 0 : assert ( storageClassIndex == sizeOfActualPool );
6565 : }
6566 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateMemberFunctionSymbol ) ;
6567 0 : std::cout << " SgTemplateMemberFunctionSymbol has size " << sizeOfActualPool << std::endl;
6568 0 : SgTemplateMemberFunctionSymbolStorageClass* SgTemplateMemberFunctionSymbolStorageArray = NULL;
6569 0 : if ( 0 < sizeOfActualPool )
6570 : {
6571 0 : SgTemplateMemberFunctionSymbolStorageArray = new SgTemplateMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
6572 0 : unsigned long storageClassIndex = SgTemplateMemberFunctionSymbol::initializeStorageClassArray (SgTemplateMemberFunctionSymbolStorageArray); ;
6573 0 : assert ( storageClassIndex == sizeOfActualPool );
6574 : }
6575 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateTypedefDeclaration ) ;
6576 0 : std::cout << " SgTemplateTypedefDeclaration has size " << sizeOfActualPool << std::endl;
6577 0 : SgTemplateTypedefDeclarationStorageClass* SgTemplateTypedefDeclarationStorageArray = NULL;
6578 0 : if ( 0 < sizeOfActualPool )
6579 : {
6580 0 : SgTemplateTypedefDeclarationStorageArray = new SgTemplateTypedefDeclarationStorageClass[sizeOfActualPool] ;
6581 0 : unsigned long storageClassIndex = SgTemplateTypedefDeclaration::initializeStorageClassArray (SgTemplateTypedefDeclarationStorageArray); ;
6582 0 : assert ( storageClassIndex == sizeOfActualPool );
6583 : }
6584 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateTypedefSymbol ) ;
6585 0 : std::cout << " SgTemplateTypedefSymbol has size " << sizeOfActualPool << std::endl;
6586 0 : SgTemplateTypedefSymbolStorageClass* SgTemplateTypedefSymbolStorageArray = NULL;
6587 0 : if ( 0 < sizeOfActualPool )
6588 : {
6589 0 : SgTemplateTypedefSymbolStorageArray = new SgTemplateTypedefSymbolStorageClass[sizeOfActualPool] ;
6590 0 : unsigned long storageClassIndex = SgTemplateTypedefSymbol::initializeStorageClassArray (SgTemplateTypedefSymbolStorageArray); ;
6591 0 : assert ( storageClassIndex == sizeOfActualPool );
6592 : }
6593 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateVariableDeclaration ) ;
6594 0 : std::cout << " SgTemplateVariableDeclaration has size " << sizeOfActualPool << std::endl;
6595 0 : SgTemplateVariableDeclarationStorageClass* SgTemplateVariableDeclarationStorageArray = NULL;
6596 0 : if ( 0 < sizeOfActualPool )
6597 : {
6598 0 : SgTemplateVariableDeclarationStorageArray = new SgTemplateVariableDeclarationStorageClass[sizeOfActualPool] ;
6599 0 : unsigned long storageClassIndex = SgTemplateVariableDeclaration::initializeStorageClassArray (SgTemplateVariableDeclarationStorageArray); ;
6600 0 : assert ( storageClassIndex == sizeOfActualPool );
6601 : }
6602 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateVariableSymbol ) ;
6603 0 : std::cout << " SgTemplateVariableSymbol has size " << sizeOfActualPool << std::endl;
6604 0 : SgTemplateVariableSymbolStorageClass* SgTemplateVariableSymbolStorageArray = NULL;
6605 0 : if ( 0 < sizeOfActualPool )
6606 : {
6607 0 : SgTemplateVariableSymbolStorageArray = new SgTemplateVariableSymbolStorageClass[sizeOfActualPool] ;
6608 0 : unsigned long storageClassIndex = SgTemplateVariableSymbol::initializeStorageClassArray (SgTemplateVariableSymbolStorageArray); ;
6609 0 : assert ( storageClassIndex == sizeOfActualPool );
6610 : }
6611 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateClassDefinition ) ;
6612 0 : std::cout << " SgTemplateClassDefinition has size " << sizeOfActualPool << std::endl;
6613 0 : SgTemplateClassDefinitionStorageClass* SgTemplateClassDefinitionStorageArray = NULL;
6614 0 : if ( 0 < sizeOfActualPool )
6615 : {
6616 0 : SgTemplateClassDefinitionStorageArray = new SgTemplateClassDefinitionStorageClass[sizeOfActualPool] ;
6617 0 : unsigned long storageClassIndex = SgTemplateClassDefinition::initializeStorageClassArray (SgTemplateClassDefinitionStorageArray); ;
6618 0 : assert ( storageClassIndex == sizeOfActualPool );
6619 : }
6620 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateFunctionDefinition ) ;
6621 0 : std::cout << " SgTemplateFunctionDefinition has size " << sizeOfActualPool << std::endl;
6622 0 : SgTemplateFunctionDefinitionStorageClass* SgTemplateFunctionDefinitionStorageArray = NULL;
6623 0 : if ( 0 < sizeOfActualPool )
6624 : {
6625 0 : SgTemplateFunctionDefinitionStorageArray = new SgTemplateFunctionDefinitionStorageClass[sizeOfActualPool] ;
6626 0 : unsigned long storageClassIndex = SgTemplateFunctionDefinition::initializeStorageClassArray (SgTemplateFunctionDefinitionStorageArray); ;
6627 0 : assert ( storageClassIndex == sizeOfActualPool );
6628 : }
6629 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationDecl ) ;
6630 0 : std::cout << " SgTemplateInstantiationDecl has size " << sizeOfActualPool << std::endl;
6631 0 : SgTemplateInstantiationDeclStorageClass* SgTemplateInstantiationDeclStorageArray = NULL;
6632 0 : if ( 0 < sizeOfActualPool )
6633 : {
6634 0 : SgTemplateInstantiationDeclStorageArray = new SgTemplateInstantiationDeclStorageClass[sizeOfActualPool] ;
6635 0 : unsigned long storageClassIndex = SgTemplateInstantiationDecl::initializeStorageClassArray (SgTemplateInstantiationDeclStorageArray); ;
6636 0 : assert ( storageClassIndex == sizeOfActualPool );
6637 : }
6638 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationDefn ) ;
6639 0 : std::cout << " SgTemplateInstantiationDefn has size " << sizeOfActualPool << std::endl;
6640 0 : SgTemplateInstantiationDefnStorageClass* SgTemplateInstantiationDefnStorageArray = NULL;
6641 0 : if ( 0 < sizeOfActualPool )
6642 : {
6643 0 : SgTemplateInstantiationDefnStorageArray = new SgTemplateInstantiationDefnStorageClass[sizeOfActualPool] ;
6644 0 : unsigned long storageClassIndex = SgTemplateInstantiationDefn::initializeStorageClassArray (SgTemplateInstantiationDefnStorageArray); ;
6645 0 : assert ( storageClassIndex == sizeOfActualPool );
6646 : }
6647 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationDirectiveStatement ) ;
6648 0 : std::cout << " SgTemplateInstantiationDirectiveStatement has size " << sizeOfActualPool << std::endl;
6649 0 : SgTemplateInstantiationDirectiveStatementStorageClass* SgTemplateInstantiationDirectiveStatementStorageArray = NULL;
6650 0 : if ( 0 < sizeOfActualPool )
6651 : {
6652 0 : SgTemplateInstantiationDirectiveStatementStorageArray = new SgTemplateInstantiationDirectiveStatementStorageClass[sizeOfActualPool] ;
6653 0 : unsigned long storageClassIndex = SgTemplateInstantiationDirectiveStatement::initializeStorageClassArray (SgTemplateInstantiationDirectiveStatementStorageArray); ;
6654 0 : assert ( storageClassIndex == sizeOfActualPool );
6655 : }
6656 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationFunctionDecl ) ;
6657 0 : std::cout << " SgTemplateInstantiationFunctionDecl has size " << sizeOfActualPool << std::endl;
6658 0 : SgTemplateInstantiationFunctionDeclStorageClass* SgTemplateInstantiationFunctionDeclStorageArray = NULL;
6659 0 : if ( 0 < sizeOfActualPool )
6660 : {
6661 0 : SgTemplateInstantiationFunctionDeclStorageArray = new SgTemplateInstantiationFunctionDeclStorageClass[sizeOfActualPool] ;
6662 0 : unsigned long storageClassIndex = SgTemplateInstantiationFunctionDecl::initializeStorageClassArray (SgTemplateInstantiationFunctionDeclStorageArray); ;
6663 0 : assert ( storageClassIndex == sizeOfActualPool );
6664 : }
6665 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationMemberFunctionDecl ) ;
6666 0 : std::cout << " SgTemplateInstantiationMemberFunctionDecl has size " << sizeOfActualPool << std::endl;
6667 0 : SgTemplateInstantiationMemberFunctionDeclStorageClass* SgTemplateInstantiationMemberFunctionDeclStorageArray = NULL;
6668 0 : if ( 0 < sizeOfActualPool )
6669 : {
6670 0 : SgTemplateInstantiationMemberFunctionDeclStorageArray = new SgTemplateInstantiationMemberFunctionDeclStorageClass[sizeOfActualPool] ;
6671 0 : unsigned long storageClassIndex = SgTemplateInstantiationMemberFunctionDecl::initializeStorageClassArray (SgTemplateInstantiationMemberFunctionDeclStorageArray); ;
6672 0 : assert ( storageClassIndex == sizeOfActualPool );
6673 : }
6674 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateInstantiationTypedefDeclaration ) ;
6675 0 : std::cout << " SgTemplateInstantiationTypedefDeclaration has size " << sizeOfActualPool << std::endl;
6676 0 : SgTemplateInstantiationTypedefDeclarationStorageClass* SgTemplateInstantiationTypedefDeclarationStorageArray = NULL;
6677 0 : if ( 0 < sizeOfActualPool )
6678 : {
6679 0 : SgTemplateInstantiationTypedefDeclarationStorageArray = new SgTemplateInstantiationTypedefDeclarationStorageClass[sizeOfActualPool] ;
6680 0 : unsigned long storageClassIndex = SgTemplateInstantiationTypedefDeclaration::initializeStorageClassArray (SgTemplateInstantiationTypedefDeclarationStorageArray); ;
6681 0 : assert ( storageClassIndex == sizeOfActualPool );
6682 : }
6683 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateParameter ) ;
6684 0 : std::cout << " SgTemplateParameter has size " << sizeOfActualPool << std::endl;
6685 0 : SgTemplateParameterStorageClass* SgTemplateParameterStorageArray = NULL;
6686 0 : if ( 0 < sizeOfActualPool )
6687 : {
6688 0 : SgTemplateParameterStorageArray = new SgTemplateParameterStorageClass[sizeOfActualPool] ;
6689 0 : unsigned long storageClassIndex = SgTemplateParameter::initializeStorageClassArray (SgTemplateParameterStorageArray); ;
6690 0 : assert ( storageClassIndex == sizeOfActualPool );
6691 : }
6692 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateParameterVal ) ;
6693 0 : std::cout << " SgTemplateParameterVal has size " << sizeOfActualPool << std::endl;
6694 0 : SgTemplateParameterValStorageClass* SgTemplateParameterValStorageArray = NULL;
6695 0 : if ( 0 < sizeOfActualPool )
6696 : {
6697 0 : SgTemplateParameterValStorageArray = new SgTemplateParameterValStorageClass[sizeOfActualPool] ;
6698 0 : unsigned long storageClassIndex = SgTemplateParameterVal::initializeStorageClassArray (SgTemplateParameterValStorageArray); ;
6699 0 : assert ( storageClassIndex == sizeOfActualPool );
6700 : }
6701 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateParameterList ) ;
6702 0 : std::cout << " SgTemplateParameterList has size " << sizeOfActualPool << std::endl;
6703 0 : SgTemplateParameterListStorageClass* SgTemplateParameterListStorageArray = NULL;
6704 0 : if ( 0 < sizeOfActualPool )
6705 : {
6706 0 : SgTemplateParameterListStorageArray = new SgTemplateParameterListStorageClass[sizeOfActualPool] ;
6707 0 : unsigned long storageClassIndex = SgTemplateParameterList::initializeStorageClassArray (SgTemplateParameterListStorageArray); ;
6708 0 : assert ( storageClassIndex == sizeOfActualPool );
6709 : }
6710 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateSymbol ) ;
6711 0 : std::cout << " SgTemplateSymbol has size " << sizeOfActualPool << std::endl;
6712 0 : SgTemplateSymbolStorageClass* SgTemplateSymbolStorageArray = NULL;
6713 0 : if ( 0 < sizeOfActualPool )
6714 : {
6715 0 : SgTemplateSymbolStorageArray = new SgTemplateSymbolStorageClass[sizeOfActualPool] ;
6716 0 : unsigned long storageClassIndex = SgTemplateSymbol::initializeStorageClassArray (SgTemplateSymbolStorageArray); ;
6717 0 : assert ( storageClassIndex == sizeOfActualPool );
6718 : }
6719 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTemplateType ) ;
6720 0 : std::cout << " SgTemplateType has size " << sizeOfActualPool << std::endl;
6721 0 : SgTemplateTypeStorageClass* SgTemplateTypeStorageArray = NULL;
6722 0 : if ( 0 < sizeOfActualPool )
6723 : {
6724 0 : SgTemplateTypeStorageArray = new SgTemplateTypeStorageClass[sizeOfActualPool] ;
6725 0 : unsigned long storageClassIndex = SgTemplateType::initializeStorageClassArray (SgTemplateTypeStorageArray); ;
6726 0 : assert ( storageClassIndex == sizeOfActualPool );
6727 : }
6728 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgThisExp ) ;
6729 0 : std::cout << " SgThisExp has size " << sizeOfActualPool << std::endl;
6730 0 : SgThisExpStorageClass* SgThisExpStorageArray = NULL;
6731 0 : if ( 0 < sizeOfActualPool )
6732 : {
6733 0 : SgThisExpStorageArray = new SgThisExpStorageClass[sizeOfActualPool] ;
6734 0 : unsigned long storageClassIndex = SgThisExp::initializeStorageClassArray (SgThisExpStorageArray); ;
6735 0 : assert ( storageClassIndex == sizeOfActualPool );
6736 : }
6737 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeTraitBuiltinOperator ) ;
6738 0 : std::cout << " SgTypeTraitBuiltinOperator has size " << sizeOfActualPool << std::endl;
6739 0 : SgTypeTraitBuiltinOperatorStorageClass* SgTypeTraitBuiltinOperatorStorageArray = NULL;
6740 0 : if ( 0 < sizeOfActualPool )
6741 : {
6742 0 : SgTypeTraitBuiltinOperatorStorageArray = new SgTypeTraitBuiltinOperatorStorageClass[sizeOfActualPool] ;
6743 0 : unsigned long storageClassIndex = SgTypeTraitBuiltinOperator::initializeStorageClassArray (SgTypeTraitBuiltinOperatorStorageArray); ;
6744 0 : assert ( storageClassIndex == sizeOfActualPool );
6745 : }
6746 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgSuperExp ) ;
6747 0 : std::cout << " SgSuperExp has size " << sizeOfActualPool << std::endl;
6748 0 : SgSuperExpStorageClass* SgSuperExpStorageArray = NULL;
6749 0 : if ( 0 < sizeOfActualPool )
6750 : {
6751 0 : SgSuperExpStorageArray = new SgSuperExpStorageClass[sizeOfActualPool] ;
6752 0 : unsigned long storageClassIndex = SgSuperExp::initializeStorageClassArray (SgSuperExpStorageArray); ;
6753 0 : assert ( storageClassIndex == sizeOfActualPool );
6754 : }
6755 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgThrowOp ) ;
6756 0 : std::cout << " SgThrowOp has size " << sizeOfActualPool << std::endl;
6757 0 : SgThrowOpStorageClass* SgThrowOpStorageArray = NULL;
6758 0 : if ( 0 < sizeOfActualPool )
6759 : {
6760 0 : SgThrowOpStorageArray = new SgThrowOpStorageClass[sizeOfActualPool] ;
6761 0 : unsigned long storageClassIndex = SgThrowOp::initializeStorageClassArray (SgThrowOpStorageArray); ;
6762 0 : assert ( storageClassIndex == sizeOfActualPool );
6763 : }
6764 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgToken ) ;
6765 0 : std::cout << " SgToken has size " << sizeOfActualPool << std::endl;
6766 0 : SgTokenStorageClass* SgTokenStorageArray = NULL;
6767 0 : if ( 0 < sizeOfActualPool )
6768 : {
6769 0 : SgTokenStorageArray = new SgTokenStorageClass[sizeOfActualPool] ;
6770 0 : unsigned long storageClassIndex = SgToken::initializeStorageClassArray (SgTokenStorageArray); ;
6771 0 : assert ( storageClassIndex == sizeOfActualPool );
6772 : }
6773 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTryStmt ) ;
6774 0 : std::cout << " SgTryStmt has size " << sizeOfActualPool << std::endl;
6775 0 : SgTryStmtStorageClass* SgTryStmtStorageArray = NULL;
6776 0 : if ( 0 < sizeOfActualPool )
6777 : {
6778 0 : SgTryStmtStorageArray = new SgTryStmtStorageClass[sizeOfActualPool] ;
6779 0 : unsigned long storageClassIndex = SgTryStmt::initializeStorageClassArray (SgTryStmtStorageArray); ;
6780 0 : assert ( storageClassIndex == sizeOfActualPool );
6781 : }
6782 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTupleExp ) ;
6783 0 : std::cout << " SgTupleExp has size " << sizeOfActualPool << std::endl;
6784 0 : SgTupleExpStorageClass* SgTupleExpStorageArray = NULL;
6785 0 : if ( 0 < sizeOfActualPool )
6786 : {
6787 0 : SgTupleExpStorageArray = new SgTupleExpStorageClass[sizeOfActualPool] ;
6788 0 : unsigned long storageClassIndex = SgTupleExp::initializeStorageClassArray (SgTupleExpStorageArray); ;
6789 0 : assert ( storageClassIndex == sizeOfActualPool );
6790 : }
6791 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgType ) ;
6792 0 : std::cout << " SgType has size " << sizeOfActualPool << std::endl;
6793 0 : SgTypeStorageClass* SgTypeStorageArray = NULL;
6794 0 : if ( 0 < sizeOfActualPool )
6795 : {
6796 0 : SgTypeStorageArray = new SgTypeStorageClass[sizeOfActualPool] ;
6797 0 : unsigned long storageClassIndex = SgType::initializeStorageClassArray (SgTypeStorageArray); ;
6798 0 : assert ( storageClassIndex == sizeOfActualPool );
6799 : }
6800 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeBool ) ;
6801 0 : std::cout << " SgTypeBool has size " << sizeOfActualPool << std::endl;
6802 0 : SgTypeBoolStorageClass* SgTypeBoolStorageArray = NULL;
6803 0 : if ( 0 < sizeOfActualPool )
6804 : {
6805 0 : SgTypeBoolStorageArray = new SgTypeBoolStorageClass[sizeOfActualPool] ;
6806 0 : unsigned long storageClassIndex = SgTypeBool::initializeStorageClassArray (SgTypeBoolStorageArray); ;
6807 0 : assert ( storageClassIndex == sizeOfActualPool );
6808 : }
6809 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeChar ) ;
6810 0 : std::cout << " SgTypeChar has size " << sizeOfActualPool << std::endl;
6811 0 : SgTypeCharStorageClass* SgTypeCharStorageArray = NULL;
6812 0 : if ( 0 < sizeOfActualPool )
6813 : {
6814 0 : SgTypeCharStorageArray = new SgTypeCharStorageClass[sizeOfActualPool] ;
6815 0 : unsigned long storageClassIndex = SgTypeChar::initializeStorageClassArray (SgTypeCharStorageArray); ;
6816 0 : assert ( storageClassIndex == sizeOfActualPool );
6817 : }
6818 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeChar16 ) ;
6819 0 : std::cout << " SgTypeChar16 has size " << sizeOfActualPool << std::endl;
6820 0 : SgTypeChar16StorageClass* SgTypeChar16StorageArray = NULL;
6821 0 : if ( 0 < sizeOfActualPool )
6822 : {
6823 0 : SgTypeChar16StorageArray = new SgTypeChar16StorageClass[sizeOfActualPool] ;
6824 0 : unsigned long storageClassIndex = SgTypeChar16::initializeStorageClassArray (SgTypeChar16StorageArray); ;
6825 0 : assert ( storageClassIndex == sizeOfActualPool );
6826 : }
6827 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeChar32 ) ;
6828 0 : std::cout << " SgTypeChar32 has size " << sizeOfActualPool << std::endl;
6829 0 : SgTypeChar32StorageClass* SgTypeChar32StorageArray = NULL;
6830 0 : if ( 0 < sizeOfActualPool )
6831 : {
6832 0 : SgTypeChar32StorageArray = new SgTypeChar32StorageClass[sizeOfActualPool] ;
6833 0 : unsigned long storageClassIndex = SgTypeChar32::initializeStorageClassArray (SgTypeChar32StorageArray); ;
6834 0 : assert ( storageClassIndex == sizeOfActualPool );
6835 : }
6836 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeComplex ) ;
6837 0 : std::cout << " SgTypeComplex has size " << sizeOfActualPool << std::endl;
6838 0 : SgTypeComplexStorageClass* SgTypeComplexStorageArray = NULL;
6839 0 : if ( 0 < sizeOfActualPool )
6840 : {
6841 0 : SgTypeComplexStorageArray = new SgTypeComplexStorageClass[sizeOfActualPool] ;
6842 0 : unsigned long storageClassIndex = SgTypeComplex::initializeStorageClassArray (SgTypeComplexStorageArray); ;
6843 0 : assert ( storageClassIndex == sizeOfActualPool );
6844 : }
6845 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeDefault ) ;
6846 0 : std::cout << " SgTypeDefault has size " << sizeOfActualPool << std::endl;
6847 0 : SgTypeDefaultStorageClass* SgTypeDefaultStorageArray = NULL;
6848 0 : if ( 0 < sizeOfActualPool )
6849 : {
6850 0 : SgTypeDefaultStorageArray = new SgTypeDefaultStorageClass[sizeOfActualPool] ;
6851 0 : unsigned long storageClassIndex = SgTypeDefault::initializeStorageClassArray (SgTypeDefaultStorageArray); ;
6852 0 : assert ( storageClassIndex == sizeOfActualPool );
6853 : }
6854 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeExpression ) ;
6855 0 : std::cout << " SgTypeExpression has size " << sizeOfActualPool << std::endl;
6856 0 : SgTypeExpressionStorageClass* SgTypeExpressionStorageArray = NULL;
6857 0 : if ( 0 < sizeOfActualPool )
6858 : {
6859 0 : SgTypeExpressionStorageArray = new SgTypeExpressionStorageClass[sizeOfActualPool] ;
6860 0 : unsigned long storageClassIndex = SgTypeExpression::initializeStorageClassArray (SgTypeExpressionStorageArray); ;
6861 0 : assert ( storageClassIndex == sizeOfActualPool );
6862 : }
6863 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeLabel ) ;
6864 0 : std::cout << " SgTypeLabel has size " << sizeOfActualPool << std::endl;
6865 0 : SgTypeLabelStorageClass* SgTypeLabelStorageArray = NULL;
6866 0 : if ( 0 < sizeOfActualPool )
6867 : {
6868 0 : SgTypeLabelStorageArray = new SgTypeLabelStorageClass[sizeOfActualPool] ;
6869 0 : unsigned long storageClassIndex = SgTypeLabel::initializeStorageClassArray (SgTypeLabelStorageArray); ;
6870 0 : assert ( storageClassIndex == sizeOfActualPool );
6871 : }
6872 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeDouble ) ;
6873 0 : std::cout << " SgTypeDouble has size " << sizeOfActualPool << std::endl;
6874 0 : SgTypeDoubleStorageClass* SgTypeDoubleStorageArray = NULL;
6875 0 : if ( 0 < sizeOfActualPool )
6876 : {
6877 0 : SgTypeDoubleStorageArray = new SgTypeDoubleStorageClass[sizeOfActualPool] ;
6878 0 : unsigned long storageClassIndex = SgTypeDouble::initializeStorageClassArray (SgTypeDoubleStorageArray); ;
6879 0 : assert ( storageClassIndex == sizeOfActualPool );
6880 : }
6881 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeEllipse ) ;
6882 0 : std::cout << " SgTypeEllipse has size " << sizeOfActualPool << std::endl;
6883 0 : SgTypeEllipseStorageClass* SgTypeEllipseStorageArray = NULL;
6884 0 : if ( 0 < sizeOfActualPool )
6885 : {
6886 0 : SgTypeEllipseStorageArray = new SgTypeEllipseStorageClass[sizeOfActualPool] ;
6887 0 : unsigned long storageClassIndex = SgTypeEllipse::initializeStorageClassArray (SgTypeEllipseStorageArray); ;
6888 0 : assert ( storageClassIndex == sizeOfActualPool );
6889 : }
6890 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeFixed ) ;
6891 0 : std::cout << " SgTypeFixed has size " << sizeOfActualPool << std::endl;
6892 0 : SgTypeFixedStorageClass* SgTypeFixedStorageArray = NULL;
6893 0 : if ( 0 < sizeOfActualPool )
6894 : {
6895 0 : SgTypeFixedStorageArray = new SgTypeFixedStorageClass[sizeOfActualPool] ;
6896 0 : unsigned long storageClassIndex = SgTypeFixed::initializeStorageClassArray (SgTypeFixedStorageArray); ;
6897 0 : assert ( storageClassIndex == sizeOfActualPool );
6898 : }
6899 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeFloat ) ;
6900 0 : std::cout << " SgTypeFloat has size " << sizeOfActualPool << std::endl;
6901 0 : SgTypeFloatStorageClass* SgTypeFloatStorageArray = NULL;
6902 0 : if ( 0 < sizeOfActualPool )
6903 : {
6904 0 : SgTypeFloatStorageArray = new SgTypeFloatStorageClass[sizeOfActualPool] ;
6905 0 : unsigned long storageClassIndex = SgTypeFloat::initializeStorageClassArray (SgTypeFloatStorageArray); ;
6906 0 : assert ( storageClassIndex == sizeOfActualPool );
6907 : }
6908 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeFloat128 ) ;
6909 0 : std::cout << " SgTypeFloat128 has size " << sizeOfActualPool << std::endl;
6910 0 : SgTypeFloat128StorageClass* SgTypeFloat128StorageArray = NULL;
6911 0 : if ( 0 < sizeOfActualPool )
6912 : {
6913 0 : SgTypeFloat128StorageArray = new SgTypeFloat128StorageClass[sizeOfActualPool] ;
6914 0 : unsigned long storageClassIndex = SgTypeFloat128::initializeStorageClassArray (SgTypeFloat128StorageArray); ;
6915 0 : assert ( storageClassIndex == sizeOfActualPool );
6916 : }
6917 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeFloat80 ) ;
6918 0 : std::cout << " SgTypeFloat80 has size " << sizeOfActualPool << std::endl;
6919 0 : SgTypeFloat80StorageClass* SgTypeFloat80StorageArray = NULL;
6920 0 : if ( 0 < sizeOfActualPool )
6921 : {
6922 0 : SgTypeFloat80StorageArray = new SgTypeFloat80StorageClass[sizeOfActualPool] ;
6923 0 : unsigned long storageClassIndex = SgTypeFloat80::initializeStorageClassArray (SgTypeFloat80StorageArray); ;
6924 0 : assert ( storageClassIndex == sizeOfActualPool );
6925 : }
6926 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeGlobalVoid ) ;
6927 0 : std::cout << " SgTypeGlobalVoid has size " << sizeOfActualPool << std::endl;
6928 0 : SgTypeGlobalVoidStorageClass* SgTypeGlobalVoidStorageArray = NULL;
6929 0 : if ( 0 < sizeOfActualPool )
6930 : {
6931 0 : SgTypeGlobalVoidStorageArray = new SgTypeGlobalVoidStorageClass[sizeOfActualPool] ;
6932 0 : unsigned long storageClassIndex = SgTypeGlobalVoid::initializeStorageClassArray (SgTypeGlobalVoidStorageArray); ;
6933 0 : assert ( storageClassIndex == sizeOfActualPool );
6934 : }
6935 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeIdOp ) ;
6936 0 : std::cout << " SgTypeIdOp has size " << sizeOfActualPool << std::endl;
6937 0 : SgTypeIdOpStorageClass* SgTypeIdOpStorageArray = NULL;
6938 0 : if ( 0 < sizeOfActualPool )
6939 : {
6940 0 : SgTypeIdOpStorageArray = new SgTypeIdOpStorageClass[sizeOfActualPool] ;
6941 0 : unsigned long storageClassIndex = SgTypeIdOp::initializeStorageClassArray (SgTypeIdOpStorageArray); ;
6942 0 : assert ( storageClassIndex == sizeOfActualPool );
6943 : }
6944 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeImaginary ) ;
6945 0 : std::cout << " SgTypeImaginary has size " << sizeOfActualPool << std::endl;
6946 0 : SgTypeImaginaryStorageClass* SgTypeImaginaryStorageArray = NULL;
6947 0 : if ( 0 < sizeOfActualPool )
6948 : {
6949 0 : SgTypeImaginaryStorageArray = new SgTypeImaginaryStorageClass[sizeOfActualPool] ;
6950 0 : unsigned long storageClassIndex = SgTypeImaginary::initializeStorageClassArray (SgTypeImaginaryStorageArray); ;
6951 0 : assert ( storageClassIndex == sizeOfActualPool );
6952 : }
6953 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeInt ) ;
6954 0 : std::cout << " SgTypeInt has size " << sizeOfActualPool << std::endl;
6955 0 : SgTypeIntStorageClass* SgTypeIntStorageArray = NULL;
6956 0 : if ( 0 < sizeOfActualPool )
6957 : {
6958 0 : SgTypeIntStorageArray = new SgTypeIntStorageClass[sizeOfActualPool] ;
6959 0 : unsigned long storageClassIndex = SgTypeInt::initializeStorageClassArray (SgTypeIntStorageArray); ;
6960 0 : assert ( storageClassIndex == sizeOfActualPool );
6961 : }
6962 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeLong ) ;
6963 0 : std::cout << " SgTypeLong has size " << sizeOfActualPool << std::endl;
6964 0 : SgTypeLongStorageClass* SgTypeLongStorageArray = NULL;
6965 0 : if ( 0 < sizeOfActualPool )
6966 : {
6967 0 : SgTypeLongStorageArray = new SgTypeLongStorageClass[sizeOfActualPool] ;
6968 0 : unsigned long storageClassIndex = SgTypeLong::initializeStorageClassArray (SgTypeLongStorageArray); ;
6969 0 : assert ( storageClassIndex == sizeOfActualPool );
6970 : }
6971 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeLongDouble ) ;
6972 0 : std::cout << " SgTypeLongDouble has size " << sizeOfActualPool << std::endl;
6973 0 : SgTypeLongDoubleStorageClass* SgTypeLongDoubleStorageArray = NULL;
6974 0 : if ( 0 < sizeOfActualPool )
6975 : {
6976 0 : SgTypeLongDoubleStorageArray = new SgTypeLongDoubleStorageClass[sizeOfActualPool] ;
6977 0 : unsigned long storageClassIndex = SgTypeLongDouble::initializeStorageClassArray (SgTypeLongDoubleStorageArray); ;
6978 0 : assert ( storageClassIndex == sizeOfActualPool );
6979 : }
6980 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeLongLong ) ;
6981 0 : std::cout << " SgTypeLongLong has size " << sizeOfActualPool << std::endl;
6982 0 : SgTypeLongLongStorageClass* SgTypeLongLongStorageArray = NULL;
6983 0 : if ( 0 < sizeOfActualPool )
6984 : {
6985 0 : SgTypeLongLongStorageArray = new SgTypeLongLongStorageClass[sizeOfActualPool] ;
6986 0 : unsigned long storageClassIndex = SgTypeLongLong::initializeStorageClassArray (SgTypeLongLongStorageArray); ;
6987 0 : assert ( storageClassIndex == sizeOfActualPool );
6988 : }
6989 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeModifier ) ;
6990 0 : std::cout << " SgTypeModifier has size " << sizeOfActualPool << std::endl;
6991 0 : SgTypeModifierStorageClass* SgTypeModifierStorageArray = NULL;
6992 0 : if ( 0 < sizeOfActualPool )
6993 : {
6994 0 : SgTypeModifierStorageArray = new SgTypeModifierStorageClass[sizeOfActualPool] ;
6995 0 : unsigned long storageClassIndex = SgTypeModifier::initializeStorageClassArray (SgTypeModifierStorageArray); ;
6996 0 : assert ( storageClassIndex == sizeOfActualPool );
6997 : }
6998 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeMatrix ) ;
6999 0 : std::cout << " SgTypeMatrix has size " << sizeOfActualPool << std::endl;
7000 0 : SgTypeMatrixStorageClass* SgTypeMatrixStorageArray = NULL;
7001 0 : if ( 0 < sizeOfActualPool )
7002 : {
7003 0 : SgTypeMatrixStorageArray = new SgTypeMatrixStorageClass[sizeOfActualPool] ;
7004 0 : unsigned long storageClassIndex = SgTypeMatrix::initializeStorageClassArray (SgTypeMatrixStorageArray); ;
7005 0 : assert ( storageClassIndex == sizeOfActualPool );
7006 : }
7007 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeTuple ) ;
7008 0 : std::cout << " SgTypeTuple has size " << sizeOfActualPool << std::endl;
7009 0 : SgTypeTupleStorageClass* SgTypeTupleStorageArray = NULL;
7010 0 : if ( 0 < sizeOfActualPool )
7011 : {
7012 0 : SgTypeTupleStorageArray = new SgTypeTupleStorageClass[sizeOfActualPool] ;
7013 0 : unsigned long storageClassIndex = SgTypeTuple::initializeStorageClassArray (SgTypeTupleStorageArray); ;
7014 0 : assert ( storageClassIndex == sizeOfActualPool );
7015 : }
7016 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeNullptr ) ;
7017 0 : std::cout << " SgTypeNullptr has size " << sizeOfActualPool << std::endl;
7018 0 : SgTypeNullptrStorageClass* SgTypeNullptrStorageArray = NULL;
7019 0 : if ( 0 < sizeOfActualPool )
7020 : {
7021 0 : SgTypeNullptrStorageArray = new SgTypeNullptrStorageClass[sizeOfActualPool] ;
7022 0 : unsigned long storageClassIndex = SgTypeNullptr::initializeStorageClassArray (SgTypeNullptrStorageArray); ;
7023 0 : assert ( storageClassIndex == sizeOfActualPool );
7024 : }
7025 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeOfType ) ;
7026 0 : std::cout << " SgTypeOfType has size " << sizeOfActualPool << std::endl;
7027 0 : SgTypeOfTypeStorageClass* SgTypeOfTypeStorageArray = NULL;
7028 0 : if ( 0 < sizeOfActualPool )
7029 : {
7030 0 : SgTypeOfTypeStorageArray = new SgTypeOfTypeStorageClass[sizeOfActualPool] ;
7031 0 : unsigned long storageClassIndex = SgTypeOfType::initializeStorageClassArray (SgTypeOfTypeStorageArray); ;
7032 0 : assert ( storageClassIndex == sizeOfActualPool );
7033 : }
7034 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeShort ) ;
7035 0 : std::cout << " SgTypeShort has size " << sizeOfActualPool << std::endl;
7036 0 : SgTypeShortStorageClass* SgTypeShortStorageArray = NULL;
7037 0 : if ( 0 < sizeOfActualPool )
7038 : {
7039 0 : SgTypeShortStorageArray = new SgTypeShortStorageClass[sizeOfActualPool] ;
7040 0 : unsigned long storageClassIndex = SgTypeShort::initializeStorageClassArray (SgTypeShortStorageArray); ;
7041 0 : assert ( storageClassIndex == sizeOfActualPool );
7042 : }
7043 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSigned128bitInteger ) ;
7044 0 : std::cout << " SgTypeSigned128bitInteger has size " << sizeOfActualPool << std::endl;
7045 0 : SgTypeSigned128bitIntegerStorageClass* SgTypeSigned128bitIntegerStorageArray = NULL;
7046 0 : if ( 0 < sizeOfActualPool )
7047 : {
7048 0 : SgTypeSigned128bitIntegerStorageArray = new SgTypeSigned128bitIntegerStorageClass[sizeOfActualPool] ;
7049 0 : unsigned long storageClassIndex = SgTypeSigned128bitInteger::initializeStorageClassArray (SgTypeSigned128bitIntegerStorageArray); ;
7050 0 : assert ( storageClassIndex == sizeOfActualPool );
7051 : }
7052 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSignedChar ) ;
7053 0 : std::cout << " SgTypeSignedChar has size " << sizeOfActualPool << std::endl;
7054 0 : SgTypeSignedCharStorageClass* SgTypeSignedCharStorageArray = NULL;
7055 0 : if ( 0 < sizeOfActualPool )
7056 : {
7057 0 : SgTypeSignedCharStorageArray = new SgTypeSignedCharStorageClass[sizeOfActualPool] ;
7058 0 : unsigned long storageClassIndex = SgTypeSignedChar::initializeStorageClassArray (SgTypeSignedCharStorageArray); ;
7059 0 : assert ( storageClassIndex == sizeOfActualPool );
7060 : }
7061 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSignedInt ) ;
7062 0 : std::cout << " SgTypeSignedInt has size " << sizeOfActualPool << std::endl;
7063 0 : SgTypeSignedIntStorageClass* SgTypeSignedIntStorageArray = NULL;
7064 0 : if ( 0 < sizeOfActualPool )
7065 : {
7066 0 : SgTypeSignedIntStorageArray = new SgTypeSignedIntStorageClass[sizeOfActualPool] ;
7067 0 : unsigned long storageClassIndex = SgTypeSignedInt::initializeStorageClassArray (SgTypeSignedIntStorageArray); ;
7068 0 : assert ( storageClassIndex == sizeOfActualPool );
7069 : }
7070 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSignedLong ) ;
7071 0 : std::cout << " SgTypeSignedLong has size " << sizeOfActualPool << std::endl;
7072 0 : SgTypeSignedLongStorageClass* SgTypeSignedLongStorageArray = NULL;
7073 0 : if ( 0 < sizeOfActualPool )
7074 : {
7075 0 : SgTypeSignedLongStorageArray = new SgTypeSignedLongStorageClass[sizeOfActualPool] ;
7076 0 : unsigned long storageClassIndex = SgTypeSignedLong::initializeStorageClassArray (SgTypeSignedLongStorageArray); ;
7077 0 : assert ( storageClassIndex == sizeOfActualPool );
7078 : }
7079 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSignedLongLong ) ;
7080 0 : std::cout << " SgTypeSignedLongLong has size " << sizeOfActualPool << std::endl;
7081 0 : SgTypeSignedLongLongStorageClass* SgTypeSignedLongLongStorageArray = NULL;
7082 0 : if ( 0 < sizeOfActualPool )
7083 : {
7084 0 : SgTypeSignedLongLongStorageArray = new SgTypeSignedLongLongStorageClass[sizeOfActualPool] ;
7085 0 : unsigned long storageClassIndex = SgTypeSignedLongLong::initializeStorageClassArray (SgTypeSignedLongLongStorageArray); ;
7086 0 : assert ( storageClassIndex == sizeOfActualPool );
7087 : }
7088 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeSignedShort ) ;
7089 0 : std::cout << " SgTypeSignedShort has size " << sizeOfActualPool << std::endl;
7090 0 : SgTypeSignedShortStorageClass* SgTypeSignedShortStorageArray = NULL;
7091 0 : if ( 0 < sizeOfActualPool )
7092 : {
7093 0 : SgTypeSignedShortStorageArray = new SgTypeSignedShortStorageClass[sizeOfActualPool] ;
7094 0 : unsigned long storageClassIndex = SgTypeSignedShort::initializeStorageClassArray (SgTypeSignedShortStorageArray); ;
7095 0 : assert ( storageClassIndex == sizeOfActualPool );
7096 : }
7097 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeString ) ;
7098 0 : std::cout << " SgTypeString has size " << sizeOfActualPool << std::endl;
7099 0 : SgTypeStringStorageClass* SgTypeStringStorageArray = NULL;
7100 0 : if ( 0 < sizeOfActualPool )
7101 : {
7102 0 : SgTypeStringStorageArray = new SgTypeStringStorageClass[sizeOfActualPool] ;
7103 0 : unsigned long storageClassIndex = SgTypeString::initializeStorageClassArray (SgTypeStringStorageArray); ;
7104 0 : assert ( storageClassIndex == sizeOfActualPool );
7105 : }
7106 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnknown ) ;
7107 0 : std::cout << " SgTypeUnknown has size " << sizeOfActualPool << std::endl;
7108 0 : SgTypeUnknownStorageClass* SgTypeUnknownStorageArray = NULL;
7109 0 : if ( 0 < sizeOfActualPool )
7110 : {
7111 0 : SgTypeUnknownStorageArray = new SgTypeUnknownStorageClass[sizeOfActualPool] ;
7112 0 : unsigned long storageClassIndex = SgTypeUnknown::initializeStorageClassArray (SgTypeUnknownStorageArray); ;
7113 0 : assert ( storageClassIndex == sizeOfActualPool );
7114 : }
7115 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsigned128bitInteger ) ;
7116 0 : std::cout << " SgTypeUnsigned128bitInteger has size " << sizeOfActualPool << std::endl;
7117 0 : SgTypeUnsigned128bitIntegerStorageClass* SgTypeUnsigned128bitIntegerStorageArray = NULL;
7118 0 : if ( 0 < sizeOfActualPool )
7119 : {
7120 0 : SgTypeUnsigned128bitIntegerStorageArray = new SgTypeUnsigned128bitIntegerStorageClass[sizeOfActualPool] ;
7121 0 : unsigned long storageClassIndex = SgTypeUnsigned128bitInteger::initializeStorageClassArray (SgTypeUnsigned128bitIntegerStorageArray); ;
7122 0 : assert ( storageClassIndex == sizeOfActualPool );
7123 : }
7124 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsignedChar ) ;
7125 0 : std::cout << " SgTypeUnsignedChar has size " << sizeOfActualPool << std::endl;
7126 0 : SgTypeUnsignedCharStorageClass* SgTypeUnsignedCharStorageArray = NULL;
7127 0 : if ( 0 < sizeOfActualPool )
7128 : {
7129 0 : SgTypeUnsignedCharStorageArray = new SgTypeUnsignedCharStorageClass[sizeOfActualPool] ;
7130 0 : unsigned long storageClassIndex = SgTypeUnsignedChar::initializeStorageClassArray (SgTypeUnsignedCharStorageArray); ;
7131 0 : assert ( storageClassIndex == sizeOfActualPool );
7132 : }
7133 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsignedInt ) ;
7134 0 : std::cout << " SgTypeUnsignedInt has size " << sizeOfActualPool << std::endl;
7135 0 : SgTypeUnsignedIntStorageClass* SgTypeUnsignedIntStorageArray = NULL;
7136 0 : if ( 0 < sizeOfActualPool )
7137 : {
7138 0 : SgTypeUnsignedIntStorageArray = new SgTypeUnsignedIntStorageClass[sizeOfActualPool] ;
7139 0 : unsigned long storageClassIndex = SgTypeUnsignedInt::initializeStorageClassArray (SgTypeUnsignedIntStorageArray); ;
7140 0 : assert ( storageClassIndex == sizeOfActualPool );
7141 : }
7142 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsignedLong ) ;
7143 0 : std::cout << " SgTypeUnsignedLong has size " << sizeOfActualPool << std::endl;
7144 0 : SgTypeUnsignedLongStorageClass* SgTypeUnsignedLongStorageArray = NULL;
7145 0 : if ( 0 < sizeOfActualPool )
7146 : {
7147 0 : SgTypeUnsignedLongStorageArray = new SgTypeUnsignedLongStorageClass[sizeOfActualPool] ;
7148 0 : unsigned long storageClassIndex = SgTypeUnsignedLong::initializeStorageClassArray (SgTypeUnsignedLongStorageArray); ;
7149 0 : assert ( storageClassIndex == sizeOfActualPool );
7150 : }
7151 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsignedLongLong ) ;
7152 0 : std::cout << " SgTypeUnsignedLongLong has size " << sizeOfActualPool << std::endl;
7153 0 : SgTypeUnsignedLongLongStorageClass* SgTypeUnsignedLongLongStorageArray = NULL;
7154 0 : if ( 0 < sizeOfActualPool )
7155 : {
7156 0 : SgTypeUnsignedLongLongStorageArray = new SgTypeUnsignedLongLongStorageClass[sizeOfActualPool] ;
7157 0 : unsigned long storageClassIndex = SgTypeUnsignedLongLong::initializeStorageClassArray (SgTypeUnsignedLongLongStorageArray); ;
7158 0 : assert ( storageClassIndex == sizeOfActualPool );
7159 : }
7160 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeUnsignedShort ) ;
7161 0 : std::cout << " SgTypeUnsignedShort has size " << sizeOfActualPool << std::endl;
7162 0 : SgTypeUnsignedShortStorageClass* SgTypeUnsignedShortStorageArray = NULL;
7163 0 : if ( 0 < sizeOfActualPool )
7164 : {
7165 0 : SgTypeUnsignedShortStorageArray = new SgTypeUnsignedShortStorageClass[sizeOfActualPool] ;
7166 0 : unsigned long storageClassIndex = SgTypeUnsignedShort::initializeStorageClassArray (SgTypeUnsignedShortStorageArray); ;
7167 0 : assert ( storageClassIndex == sizeOfActualPool );
7168 : }
7169 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeVoid ) ;
7170 0 : std::cout << " SgTypeVoid has size " << sizeOfActualPool << std::endl;
7171 0 : SgTypeVoidStorageClass* SgTypeVoidStorageArray = NULL;
7172 0 : if ( 0 < sizeOfActualPool )
7173 : {
7174 0 : SgTypeVoidStorageArray = new SgTypeVoidStorageClass[sizeOfActualPool] ;
7175 0 : unsigned long storageClassIndex = SgTypeVoid::initializeStorageClassArray (SgTypeVoidStorageArray); ;
7176 0 : assert ( storageClassIndex == sizeOfActualPool );
7177 : }
7178 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeWchar ) ;
7179 0 : std::cout << " SgTypeWchar has size " << sizeOfActualPool << std::endl;
7180 0 : SgTypeWcharStorageClass* SgTypeWcharStorageArray = NULL;
7181 0 : if ( 0 < sizeOfActualPool )
7182 : {
7183 0 : SgTypeWcharStorageArray = new SgTypeWcharStorageClass[sizeOfActualPool] ;
7184 0 : unsigned long storageClassIndex = SgTypeWchar::initializeStorageClassArray (SgTypeWcharStorageArray); ;
7185 0 : assert ( storageClassIndex == sizeOfActualPool );
7186 : }
7187 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypedefDeclaration ) ;
7188 0 : std::cout << " SgTypedefDeclaration has size " << sizeOfActualPool << std::endl;
7189 0 : SgTypedefDeclarationStorageClass* SgTypedefDeclarationStorageArray = NULL;
7190 0 : if ( 0 < sizeOfActualPool )
7191 : {
7192 0 : SgTypedefDeclarationStorageArray = new SgTypedefDeclarationStorageClass[sizeOfActualPool] ;
7193 0 : unsigned long storageClassIndex = SgTypedefDeclaration::initializeStorageClassArray (SgTypedefDeclarationStorageArray); ;
7194 0 : assert ( storageClassIndex == sizeOfActualPool );
7195 : }
7196 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypedefSeq ) ;
7197 0 : std::cout << " SgTypedefSeq has size " << sizeOfActualPool << std::endl;
7198 0 : SgTypedefSeqStorageClass* SgTypedefSeqStorageArray = NULL;
7199 0 : if ( 0 < sizeOfActualPool )
7200 : {
7201 0 : SgTypedefSeqStorageArray = new SgTypedefSeqStorageClass[sizeOfActualPool] ;
7202 0 : unsigned long storageClassIndex = SgTypedefSeq::initializeStorageClassArray (SgTypedefSeqStorageArray); ;
7203 0 : assert ( storageClassIndex == sizeOfActualPool );
7204 : }
7205 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypedefSymbol ) ;
7206 0 : std::cout << " SgTypedefSymbol has size " << sizeOfActualPool << std::endl;
7207 0 : SgTypedefSymbolStorageClass* SgTypedefSymbolStorageArray = NULL;
7208 0 : if ( 0 < sizeOfActualPool )
7209 : {
7210 0 : SgTypedefSymbolStorageArray = new SgTypedefSymbolStorageClass[sizeOfActualPool] ;
7211 0 : unsigned long storageClassIndex = SgTypedefSymbol::initializeStorageClassArray (SgTypedefSymbolStorageArray); ;
7212 0 : assert ( storageClassIndex == sizeOfActualPool );
7213 : }
7214 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypedefType ) ;
7215 0 : std::cout << " SgTypedefType has size " << sizeOfActualPool << std::endl;
7216 0 : SgTypedefTypeStorageClass* SgTypedefTypeStorageArray = NULL;
7217 0 : if ( 0 < sizeOfActualPool )
7218 : {
7219 0 : SgTypedefTypeStorageArray = new SgTypedefTypeStorageClass[sizeOfActualPool] ;
7220 0 : unsigned long storageClassIndex = SgTypedefType::initializeStorageClassArray (SgTypedefTypeStorageArray); ;
7221 0 : assert ( storageClassIndex == sizeOfActualPool );
7222 : }
7223 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUPC_AccessModifier ) ;
7224 0 : std::cout << " SgUPC_AccessModifier has size " << sizeOfActualPool << std::endl;
7225 0 : SgUPC_AccessModifierStorageClass* SgUPC_AccessModifierStorageArray = NULL;
7226 0 : if ( 0 < sizeOfActualPool )
7227 : {
7228 0 : SgUPC_AccessModifierStorageArray = new SgUPC_AccessModifierStorageClass[sizeOfActualPool] ;
7229 0 : unsigned long storageClassIndex = SgUPC_AccessModifier::initializeStorageClassArray (SgUPC_AccessModifierStorageArray); ;
7230 0 : assert ( storageClassIndex == sizeOfActualPool );
7231 : }
7232 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnaryAddOp ) ;
7233 0 : std::cout << " SgUnaryAddOp has size " << sizeOfActualPool << std::endl;
7234 0 : SgUnaryAddOpStorageClass* SgUnaryAddOpStorageArray = NULL;
7235 0 : if ( 0 < sizeOfActualPool )
7236 : {
7237 0 : SgUnaryAddOpStorageArray = new SgUnaryAddOpStorageClass[sizeOfActualPool] ;
7238 0 : unsigned long storageClassIndex = SgUnaryAddOp::initializeStorageClassArray (SgUnaryAddOpStorageArray); ;
7239 0 : assert ( storageClassIndex == sizeOfActualPool );
7240 : }
7241 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnaryOp ) ;
7242 0 : std::cout << " SgUnaryOp has size " << sizeOfActualPool << std::endl;
7243 0 : SgUnaryOpStorageClass* SgUnaryOpStorageArray = NULL;
7244 0 : if ( 0 < sizeOfActualPool )
7245 : {
7246 0 : SgUnaryOpStorageArray = new SgUnaryOpStorageClass[sizeOfActualPool] ;
7247 0 : unsigned long storageClassIndex = SgUnaryOp::initializeStorageClassArray (SgUnaryOpStorageArray); ;
7248 0 : assert ( storageClassIndex == sizeOfActualPool );
7249 : }
7250 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUndefDirectiveStatement ) ;
7251 0 : std::cout << " SgUndefDirectiveStatement has size " << sizeOfActualPool << std::endl;
7252 0 : SgUndefDirectiveStatementStorageClass* SgUndefDirectiveStatementStorageArray = NULL;
7253 0 : if ( 0 < sizeOfActualPool )
7254 : {
7255 0 : SgUndefDirectiveStatementStorageArray = new SgUndefDirectiveStatementStorageClass[sizeOfActualPool] ;
7256 0 : unsigned long storageClassIndex = SgUndefDirectiveStatement::initializeStorageClassArray (SgUndefDirectiveStatementStorageArray); ;
7257 0 : assert ( storageClassIndex == sizeOfActualPool );
7258 : }
7259 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUndirectedGraphEdge ) ;
7260 0 : std::cout << " SgUndirectedGraphEdge has size " << sizeOfActualPool << std::endl;
7261 0 : SgUndirectedGraphEdgeStorageClass* SgUndirectedGraphEdgeStorageArray = NULL;
7262 0 : if ( 0 < sizeOfActualPool )
7263 : {
7264 0 : SgUndirectedGraphEdgeStorageArray = new SgUndirectedGraphEdgeStorageClass[sizeOfActualPool] ;
7265 0 : unsigned long storageClassIndex = SgUndirectedGraphEdge::initializeStorageClassArray (SgUndirectedGraphEdgeStorageArray); ;
7266 0 : assert ( storageClassIndex == sizeOfActualPool );
7267 : }
7268 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnknownArrayOrFunctionReference ) ;
7269 0 : std::cout << " SgUnknownArrayOrFunctionReference has size " << sizeOfActualPool << std::endl;
7270 0 : SgUnknownArrayOrFunctionReferenceStorageClass* SgUnknownArrayOrFunctionReferenceStorageArray = NULL;
7271 0 : if ( 0 < sizeOfActualPool )
7272 : {
7273 0 : SgUnknownArrayOrFunctionReferenceStorageArray = new SgUnknownArrayOrFunctionReferenceStorageClass[sizeOfActualPool] ;
7274 0 : unsigned long storageClassIndex = SgUnknownArrayOrFunctionReference::initializeStorageClassArray (SgUnknownArrayOrFunctionReferenceStorageArray); ;
7275 0 : assert ( storageClassIndex == sizeOfActualPool );
7276 : }
7277 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnknownFile ) ;
7278 0 : std::cout << " SgUnknownFile has size " << sizeOfActualPool << std::endl;
7279 0 : SgUnknownFileStorageClass* SgUnknownFileStorageArray = NULL;
7280 0 : if ( 0 < sizeOfActualPool )
7281 : {
7282 0 : SgUnknownFileStorageArray = new SgUnknownFileStorageClass[sizeOfActualPool] ;
7283 0 : unsigned long storageClassIndex = SgUnknownFile::initializeStorageClassArray (SgUnknownFileStorageArray); ;
7284 0 : assert ( storageClassIndex == sizeOfActualPool );
7285 : }
7286 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnparse_Info ) ;
7287 0 : std::cout << " SgUnparse_Info has size " << sizeOfActualPool << std::endl;
7288 0 : SgUnparse_InfoStorageClass* SgUnparse_InfoStorageArray = NULL;
7289 0 : if ( 0 < sizeOfActualPool )
7290 : {
7291 0 : SgUnparse_InfoStorageArray = new SgUnparse_InfoStorageClass[sizeOfActualPool] ;
7292 0 : unsigned long storageClassIndex = SgUnparse_Info::initializeStorageClassArray (SgUnparse_InfoStorageArray); ;
7293 0 : assert ( storageClassIndex == sizeOfActualPool );
7294 : }
7295 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnsignedCharVal ) ;
7296 0 : std::cout << " SgUnsignedCharVal has size " << sizeOfActualPool << std::endl;
7297 0 : SgUnsignedCharValStorageClass* SgUnsignedCharValStorageArray = NULL;
7298 0 : if ( 0 < sizeOfActualPool )
7299 : {
7300 0 : SgUnsignedCharValStorageArray = new SgUnsignedCharValStorageClass[sizeOfActualPool] ;
7301 0 : unsigned long storageClassIndex = SgUnsignedCharVal::initializeStorageClassArray (SgUnsignedCharValStorageArray); ;
7302 0 : assert ( storageClassIndex == sizeOfActualPool );
7303 : }
7304 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnsignedIntVal ) ;
7305 0 : std::cout << " SgUnsignedIntVal has size " << sizeOfActualPool << std::endl;
7306 0 : SgUnsignedIntValStorageClass* SgUnsignedIntValStorageArray = NULL;
7307 0 : if ( 0 < sizeOfActualPool )
7308 : {
7309 0 : SgUnsignedIntValStorageArray = new SgUnsignedIntValStorageClass[sizeOfActualPool] ;
7310 0 : unsigned long storageClassIndex = SgUnsignedIntVal::initializeStorageClassArray (SgUnsignedIntValStorageArray); ;
7311 0 : assert ( storageClassIndex == sizeOfActualPool );
7312 : }
7313 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnsignedLongLongIntVal ) ;
7314 0 : std::cout << " SgUnsignedLongLongIntVal has size " << sizeOfActualPool << std::endl;
7315 0 : SgUnsignedLongLongIntValStorageClass* SgUnsignedLongLongIntValStorageArray = NULL;
7316 0 : if ( 0 < sizeOfActualPool )
7317 : {
7318 0 : SgUnsignedLongLongIntValStorageArray = new SgUnsignedLongLongIntValStorageClass[sizeOfActualPool] ;
7319 0 : unsigned long storageClassIndex = SgUnsignedLongLongIntVal::initializeStorageClassArray (SgUnsignedLongLongIntValStorageArray); ;
7320 0 : assert ( storageClassIndex == sizeOfActualPool );
7321 : }
7322 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnsignedLongVal ) ;
7323 0 : std::cout << " SgUnsignedLongVal has size " << sizeOfActualPool << std::endl;
7324 0 : SgUnsignedLongValStorageClass* SgUnsignedLongValStorageArray = NULL;
7325 0 : if ( 0 < sizeOfActualPool )
7326 : {
7327 0 : SgUnsignedLongValStorageArray = new SgUnsignedLongValStorageClass[sizeOfActualPool] ;
7328 0 : unsigned long storageClassIndex = SgUnsignedLongVal::initializeStorageClassArray (SgUnsignedLongValStorageArray); ;
7329 0 : assert ( storageClassIndex == sizeOfActualPool );
7330 : }
7331 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUnsignedShortVal ) ;
7332 0 : std::cout << " SgUnsignedShortVal has size " << sizeOfActualPool << std::endl;
7333 0 : SgUnsignedShortValStorageClass* SgUnsignedShortValStorageArray = NULL;
7334 0 : if ( 0 < sizeOfActualPool )
7335 : {
7336 0 : SgUnsignedShortValStorageArray = new SgUnsignedShortValStorageClass[sizeOfActualPool] ;
7337 0 : unsigned long storageClassIndex = SgUnsignedShortVal::initializeStorageClassArray (SgUnsignedShortValStorageArray); ;
7338 0 : assert ( storageClassIndex == sizeOfActualPool );
7339 : }
7340 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcBarrierStatement ) ;
7341 0 : std::cout << " SgUpcBarrierStatement has size " << sizeOfActualPool << std::endl;
7342 0 : SgUpcBarrierStatementStorageClass* SgUpcBarrierStatementStorageArray = NULL;
7343 0 : if ( 0 < sizeOfActualPool )
7344 : {
7345 0 : SgUpcBarrierStatementStorageArray = new SgUpcBarrierStatementStorageClass[sizeOfActualPool] ;
7346 0 : unsigned long storageClassIndex = SgUpcBarrierStatement::initializeStorageClassArray (SgUpcBarrierStatementStorageArray); ;
7347 0 : assert ( storageClassIndex == sizeOfActualPool );
7348 : }
7349 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcBlocksizeofExpression ) ;
7350 0 : std::cout << " SgUpcBlocksizeofExpression has size " << sizeOfActualPool << std::endl;
7351 0 : SgUpcBlocksizeofExpressionStorageClass* SgUpcBlocksizeofExpressionStorageArray = NULL;
7352 0 : if ( 0 < sizeOfActualPool )
7353 : {
7354 0 : SgUpcBlocksizeofExpressionStorageArray = new SgUpcBlocksizeofExpressionStorageClass[sizeOfActualPool] ;
7355 0 : unsigned long storageClassIndex = SgUpcBlocksizeofExpression::initializeStorageClassArray (SgUpcBlocksizeofExpressionStorageArray); ;
7356 0 : assert ( storageClassIndex == sizeOfActualPool );
7357 : }
7358 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcElemsizeofExpression ) ;
7359 0 : std::cout << " SgUpcElemsizeofExpression has size " << sizeOfActualPool << std::endl;
7360 0 : SgUpcElemsizeofExpressionStorageClass* SgUpcElemsizeofExpressionStorageArray = NULL;
7361 0 : if ( 0 < sizeOfActualPool )
7362 : {
7363 0 : SgUpcElemsizeofExpressionStorageArray = new SgUpcElemsizeofExpressionStorageClass[sizeOfActualPool] ;
7364 0 : unsigned long storageClassIndex = SgUpcElemsizeofExpression::initializeStorageClassArray (SgUpcElemsizeofExpressionStorageArray); ;
7365 0 : assert ( storageClassIndex == sizeOfActualPool );
7366 : }
7367 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcFenceStatement ) ;
7368 0 : std::cout << " SgUpcFenceStatement has size " << sizeOfActualPool << std::endl;
7369 0 : SgUpcFenceStatementStorageClass* SgUpcFenceStatementStorageArray = NULL;
7370 0 : if ( 0 < sizeOfActualPool )
7371 : {
7372 0 : SgUpcFenceStatementStorageArray = new SgUpcFenceStatementStorageClass[sizeOfActualPool] ;
7373 0 : unsigned long storageClassIndex = SgUpcFenceStatement::initializeStorageClassArray (SgUpcFenceStatementStorageArray); ;
7374 0 : assert ( storageClassIndex == sizeOfActualPool );
7375 : }
7376 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcForAllStatement ) ;
7377 0 : std::cout << " SgUpcForAllStatement has size " << sizeOfActualPool << std::endl;
7378 0 : SgUpcForAllStatementStorageClass* SgUpcForAllStatementStorageArray = NULL;
7379 0 : if ( 0 < sizeOfActualPool )
7380 : {
7381 0 : SgUpcForAllStatementStorageArray = new SgUpcForAllStatementStorageClass[sizeOfActualPool] ;
7382 0 : unsigned long storageClassIndex = SgUpcForAllStatement::initializeStorageClassArray (SgUpcForAllStatementStorageArray); ;
7383 0 : assert ( storageClassIndex == sizeOfActualPool );
7384 : }
7385 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcLocalsizeofExpression ) ;
7386 0 : std::cout << " SgUpcLocalsizeofExpression has size " << sizeOfActualPool << std::endl;
7387 0 : SgUpcLocalsizeofExpressionStorageClass* SgUpcLocalsizeofExpressionStorageArray = NULL;
7388 0 : if ( 0 < sizeOfActualPool )
7389 : {
7390 0 : SgUpcLocalsizeofExpressionStorageArray = new SgUpcLocalsizeofExpressionStorageClass[sizeOfActualPool] ;
7391 0 : unsigned long storageClassIndex = SgUpcLocalsizeofExpression::initializeStorageClassArray (SgUpcLocalsizeofExpressionStorageArray); ;
7392 0 : assert ( storageClassIndex == sizeOfActualPool );
7393 : }
7394 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcMythread ) ;
7395 0 : std::cout << " SgUpcMythread has size " << sizeOfActualPool << std::endl;
7396 0 : SgUpcMythreadStorageClass* SgUpcMythreadStorageArray = NULL;
7397 0 : if ( 0 < sizeOfActualPool )
7398 : {
7399 0 : SgUpcMythreadStorageArray = new SgUpcMythreadStorageClass[sizeOfActualPool] ;
7400 0 : unsigned long storageClassIndex = SgUpcMythread::initializeStorageClassArray (SgUpcMythreadStorageArray); ;
7401 0 : assert ( storageClassIndex == sizeOfActualPool );
7402 : }
7403 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcNotifyStatement ) ;
7404 0 : std::cout << " SgUpcNotifyStatement has size " << sizeOfActualPool << std::endl;
7405 0 : SgUpcNotifyStatementStorageClass* SgUpcNotifyStatementStorageArray = NULL;
7406 0 : if ( 0 < sizeOfActualPool )
7407 : {
7408 0 : SgUpcNotifyStatementStorageArray = new SgUpcNotifyStatementStorageClass[sizeOfActualPool] ;
7409 0 : unsigned long storageClassIndex = SgUpcNotifyStatement::initializeStorageClassArray (SgUpcNotifyStatementStorageArray); ;
7410 0 : assert ( storageClassIndex == sizeOfActualPool );
7411 : }
7412 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcThreads ) ;
7413 0 : std::cout << " SgUpcThreads has size " << sizeOfActualPool << std::endl;
7414 0 : SgUpcThreadsStorageClass* SgUpcThreadsStorageArray = NULL;
7415 0 : if ( 0 < sizeOfActualPool )
7416 : {
7417 0 : SgUpcThreadsStorageArray = new SgUpcThreadsStorageClass[sizeOfActualPool] ;
7418 0 : unsigned long storageClassIndex = SgUpcThreads::initializeStorageClassArray (SgUpcThreadsStorageArray); ;
7419 0 : assert ( storageClassIndex == sizeOfActualPool );
7420 : }
7421 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUpcWaitStatement ) ;
7422 0 : std::cout << " SgUpcWaitStatement has size " << sizeOfActualPool << std::endl;
7423 0 : SgUpcWaitStatementStorageClass* SgUpcWaitStatementStorageArray = NULL;
7424 0 : if ( 0 < sizeOfActualPool )
7425 : {
7426 0 : SgUpcWaitStatementStorageArray = new SgUpcWaitStatementStorageClass[sizeOfActualPool] ;
7427 0 : unsigned long storageClassIndex = SgUpcWaitStatement::initializeStorageClassArray (SgUpcWaitStatementStorageArray); ;
7428 0 : assert ( storageClassIndex == sizeOfActualPool );
7429 : }
7430 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUseStatement ) ;
7431 0 : std::cout << " SgUseStatement has size " << sizeOfActualPool << std::endl;
7432 0 : SgUseStatementStorageClass* SgUseStatementStorageArray = NULL;
7433 0 : if ( 0 < sizeOfActualPool )
7434 : {
7435 0 : SgUseStatementStorageArray = new SgUseStatementStorageClass[sizeOfActualPool] ;
7436 0 : unsigned long storageClassIndex = SgUseStatement::initializeStorageClassArray (SgUseStatementStorageArray); ;
7437 0 : assert ( storageClassIndex == sizeOfActualPool );
7438 : }
7439 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUserDefinedBinaryOp ) ;
7440 0 : std::cout << " SgUserDefinedBinaryOp has size " << sizeOfActualPool << std::endl;
7441 0 : SgUserDefinedBinaryOpStorageClass* SgUserDefinedBinaryOpStorageArray = NULL;
7442 0 : if ( 0 < sizeOfActualPool )
7443 : {
7444 0 : SgUserDefinedBinaryOpStorageArray = new SgUserDefinedBinaryOpStorageClass[sizeOfActualPool] ;
7445 0 : unsigned long storageClassIndex = SgUserDefinedBinaryOp::initializeStorageClassArray (SgUserDefinedBinaryOpStorageArray); ;
7446 0 : assert ( storageClassIndex == sizeOfActualPool );
7447 : }
7448 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUserDefinedUnaryOp ) ;
7449 0 : std::cout << " SgUserDefinedUnaryOp has size " << sizeOfActualPool << std::endl;
7450 0 : SgUserDefinedUnaryOpStorageClass* SgUserDefinedUnaryOpStorageArray = NULL;
7451 0 : if ( 0 < sizeOfActualPool )
7452 : {
7453 0 : SgUserDefinedUnaryOpStorageArray = new SgUserDefinedUnaryOpStorageClass[sizeOfActualPool] ;
7454 0 : unsigned long storageClassIndex = SgUserDefinedUnaryOp::initializeStorageClassArray (SgUserDefinedUnaryOpStorageArray); ;
7455 0 : assert ( storageClassIndex == sizeOfActualPool );
7456 : }
7457 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUsingDeclarationStatement ) ;
7458 0 : std::cout << " SgUsingDeclarationStatement has size " << sizeOfActualPool << std::endl;
7459 0 : SgUsingDeclarationStatementStorageClass* SgUsingDeclarationStatementStorageArray = NULL;
7460 0 : if ( 0 < sizeOfActualPool )
7461 : {
7462 0 : SgUsingDeclarationStatementStorageArray = new SgUsingDeclarationStatementStorageClass[sizeOfActualPool] ;
7463 0 : unsigned long storageClassIndex = SgUsingDeclarationStatement::initializeStorageClassArray (SgUsingDeclarationStatementStorageArray); ;
7464 0 : assert ( storageClassIndex == sizeOfActualPool );
7465 : }
7466 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgUsingDirectiveStatement ) ;
7467 0 : std::cout << " SgUsingDirectiveStatement has size " << sizeOfActualPool << std::endl;
7468 0 : SgUsingDirectiveStatementStorageClass* SgUsingDirectiveStatementStorageArray = NULL;
7469 0 : if ( 0 < sizeOfActualPool )
7470 : {
7471 0 : SgUsingDirectiveStatementStorageArray = new SgUsingDirectiveStatementStorageClass[sizeOfActualPool] ;
7472 0 : unsigned long storageClassIndex = SgUsingDirectiveStatement::initializeStorageClassArray (SgUsingDirectiveStatementStorageArray); ;
7473 0 : assert ( storageClassIndex == sizeOfActualPool );
7474 : }
7475 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgValueExp ) ;
7476 0 : std::cout << " SgValueExp has size " << sizeOfActualPool << std::endl;
7477 0 : SgValueExpStorageClass* SgValueExpStorageArray = NULL;
7478 0 : if ( 0 < sizeOfActualPool )
7479 : {
7480 0 : SgValueExpStorageArray = new SgValueExpStorageClass[sizeOfActualPool] ;
7481 0 : unsigned long storageClassIndex = SgValueExp::initializeStorageClassArray (SgValueExpStorageArray); ;
7482 0 : assert ( storageClassIndex == sizeOfActualPool );
7483 : }
7484 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarArgCopyOp ) ;
7485 0 : std::cout << " SgVarArgCopyOp has size " << sizeOfActualPool << std::endl;
7486 0 : SgVarArgCopyOpStorageClass* SgVarArgCopyOpStorageArray = NULL;
7487 0 : if ( 0 < sizeOfActualPool )
7488 : {
7489 0 : SgVarArgCopyOpStorageArray = new SgVarArgCopyOpStorageClass[sizeOfActualPool] ;
7490 0 : unsigned long storageClassIndex = SgVarArgCopyOp::initializeStorageClassArray (SgVarArgCopyOpStorageArray); ;
7491 0 : assert ( storageClassIndex == sizeOfActualPool );
7492 : }
7493 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarArgEndOp ) ;
7494 0 : std::cout << " SgVarArgEndOp has size " << sizeOfActualPool << std::endl;
7495 0 : SgVarArgEndOpStorageClass* SgVarArgEndOpStorageArray = NULL;
7496 0 : if ( 0 < sizeOfActualPool )
7497 : {
7498 0 : SgVarArgEndOpStorageArray = new SgVarArgEndOpStorageClass[sizeOfActualPool] ;
7499 0 : unsigned long storageClassIndex = SgVarArgEndOp::initializeStorageClassArray (SgVarArgEndOpStorageArray); ;
7500 0 : assert ( storageClassIndex == sizeOfActualPool );
7501 : }
7502 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarArgOp ) ;
7503 0 : std::cout << " SgVarArgOp has size " << sizeOfActualPool << std::endl;
7504 0 : SgVarArgOpStorageClass* SgVarArgOpStorageArray = NULL;
7505 0 : if ( 0 < sizeOfActualPool )
7506 : {
7507 0 : SgVarArgOpStorageArray = new SgVarArgOpStorageClass[sizeOfActualPool] ;
7508 0 : unsigned long storageClassIndex = SgVarArgOp::initializeStorageClassArray (SgVarArgOpStorageArray); ;
7509 0 : assert ( storageClassIndex == sizeOfActualPool );
7510 : }
7511 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarArgStartOneOperandOp ) ;
7512 0 : std::cout << " SgVarArgStartOneOperandOp has size " << sizeOfActualPool << std::endl;
7513 0 : SgVarArgStartOneOperandOpStorageClass* SgVarArgStartOneOperandOpStorageArray = NULL;
7514 0 : if ( 0 < sizeOfActualPool )
7515 : {
7516 0 : SgVarArgStartOneOperandOpStorageArray = new SgVarArgStartOneOperandOpStorageClass[sizeOfActualPool] ;
7517 0 : unsigned long storageClassIndex = SgVarArgStartOneOperandOp::initializeStorageClassArray (SgVarArgStartOneOperandOpStorageArray); ;
7518 0 : assert ( storageClassIndex == sizeOfActualPool );
7519 : }
7520 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarArgStartOp ) ;
7521 0 : std::cout << " SgVarArgStartOp has size " << sizeOfActualPool << std::endl;
7522 0 : SgVarArgStartOpStorageClass* SgVarArgStartOpStorageArray = NULL;
7523 0 : if ( 0 < sizeOfActualPool )
7524 : {
7525 0 : SgVarArgStartOpStorageArray = new SgVarArgStartOpStorageClass[sizeOfActualPool] ;
7526 0 : unsigned long storageClassIndex = SgVarArgStartOp::initializeStorageClassArray (SgVarArgStartOpStorageArray); ;
7527 0 : assert ( storageClassIndex == sizeOfActualPool );
7528 : }
7529 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVarRefExp ) ;
7530 0 : std::cout << " SgVarRefExp has size " << sizeOfActualPool << std::endl;
7531 0 : SgVarRefExpStorageClass* SgVarRefExpStorageArray = NULL;
7532 0 : if ( 0 < sizeOfActualPool )
7533 : {
7534 0 : SgVarRefExpStorageArray = new SgVarRefExpStorageClass[sizeOfActualPool] ;
7535 0 : unsigned long storageClassIndex = SgVarRefExp::initializeStorageClassArray (SgVarRefExpStorageArray); ;
7536 0 : assert ( storageClassIndex == sizeOfActualPool );
7537 : }
7538 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVariableDeclaration ) ;
7539 0 : std::cout << " SgVariableDeclaration has size " << sizeOfActualPool << std::endl;
7540 0 : SgVariableDeclarationStorageClass* SgVariableDeclarationStorageArray = NULL;
7541 0 : if ( 0 < sizeOfActualPool )
7542 : {
7543 0 : SgVariableDeclarationStorageArray = new SgVariableDeclarationStorageClass[sizeOfActualPool] ;
7544 0 : unsigned long storageClassIndex = SgVariableDeclaration::initializeStorageClassArray (SgVariableDeclarationStorageArray); ;
7545 0 : assert ( storageClassIndex == sizeOfActualPool );
7546 : }
7547 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVariableDefinition ) ;
7548 0 : std::cout << " SgVariableDefinition has size " << sizeOfActualPool << std::endl;
7549 0 : SgVariableDefinitionStorageClass* SgVariableDefinitionStorageArray = NULL;
7550 0 : if ( 0 < sizeOfActualPool )
7551 : {
7552 0 : SgVariableDefinitionStorageArray = new SgVariableDefinitionStorageClass[sizeOfActualPool] ;
7553 0 : unsigned long storageClassIndex = SgVariableDefinition::initializeStorageClassArray (SgVariableDefinitionStorageArray); ;
7554 0 : assert ( storageClassIndex == sizeOfActualPool );
7555 : }
7556 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVariableSymbol ) ;
7557 0 : std::cout << " SgVariableSymbol has size " << sizeOfActualPool << std::endl;
7558 0 : SgVariableSymbolStorageClass* SgVariableSymbolStorageArray = NULL;
7559 0 : if ( 0 < sizeOfActualPool )
7560 : {
7561 0 : SgVariableSymbolStorageArray = new SgVariableSymbolStorageClass[sizeOfActualPool] ;
7562 0 : unsigned long storageClassIndex = SgVariableSymbol::initializeStorageClassArray (SgVariableSymbolStorageArray); ;
7563 0 : assert ( storageClassIndex == sizeOfActualPool );
7564 : }
7565 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVariantExpression ) ;
7566 0 : std::cout << " SgVariantExpression has size " << sizeOfActualPool << std::endl;
7567 0 : SgVariantExpressionStorageClass* SgVariantExpressionStorageArray = NULL;
7568 0 : if ( 0 < sizeOfActualPool )
7569 : {
7570 0 : SgVariantExpressionStorageArray = new SgVariantExpressionStorageClass[sizeOfActualPool] ;
7571 0 : unsigned long storageClassIndex = SgVariantExpression::initializeStorageClassArray (SgVariantExpressionStorageArray); ;
7572 0 : assert ( storageClassIndex == sizeOfActualPool );
7573 : }
7574 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVariantStatement ) ;
7575 0 : std::cout << " SgVariantStatement has size " << sizeOfActualPool << std::endl;
7576 0 : SgVariantStatementStorageClass* SgVariantStatementStorageArray = NULL;
7577 0 : if ( 0 < sizeOfActualPool )
7578 : {
7579 0 : SgVariantStatementStorageArray = new SgVariantStatementStorageClass[sizeOfActualPool] ;
7580 0 : unsigned long storageClassIndex = SgVariantStatement::initializeStorageClassArray (SgVariantStatementStorageArray); ;
7581 0 : assert ( storageClassIndex == sizeOfActualPool );
7582 : }
7583 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgVoidVal ) ;
7584 0 : std::cout << " SgVoidVal has size " << sizeOfActualPool << std::endl;
7585 0 : SgVoidValStorageClass* SgVoidValStorageArray = NULL;
7586 0 : if ( 0 < sizeOfActualPool )
7587 : {
7588 0 : SgVoidValStorageArray = new SgVoidValStorageClass[sizeOfActualPool] ;
7589 0 : unsigned long storageClassIndex = SgVoidVal::initializeStorageClassArray (SgVoidValStorageArray); ;
7590 0 : assert ( storageClassIndex == sizeOfActualPool );
7591 : }
7592 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWaitStatement ) ;
7593 0 : std::cout << " SgWaitStatement has size " << sizeOfActualPool << std::endl;
7594 0 : SgWaitStatementStorageClass* SgWaitStatementStorageArray = NULL;
7595 0 : if ( 0 < sizeOfActualPool )
7596 : {
7597 0 : SgWaitStatementStorageArray = new SgWaitStatementStorageClass[sizeOfActualPool] ;
7598 0 : unsigned long storageClassIndex = SgWaitStatement::initializeStorageClassArray (SgWaitStatementStorageArray); ;
7599 0 : assert ( storageClassIndex == sizeOfActualPool );
7600 : }
7601 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWarningDirectiveStatement ) ;
7602 0 : std::cout << " SgWarningDirectiveStatement has size " << sizeOfActualPool << std::endl;
7603 0 : SgWarningDirectiveStatementStorageClass* SgWarningDirectiveStatementStorageArray = NULL;
7604 0 : if ( 0 < sizeOfActualPool )
7605 : {
7606 0 : SgWarningDirectiveStatementStorageArray = new SgWarningDirectiveStatementStorageClass[sizeOfActualPool] ;
7607 0 : unsigned long storageClassIndex = SgWarningDirectiveStatement::initializeStorageClassArray (SgWarningDirectiveStatementStorageArray); ;
7608 0 : assert ( storageClassIndex == sizeOfActualPool );
7609 : }
7610 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWithStatement ) ;
7611 0 : std::cout << " SgWithStatement has size " << sizeOfActualPool << std::endl;
7612 0 : SgWithStatementStorageClass* SgWithStatementStorageArray = NULL;
7613 0 : if ( 0 < sizeOfActualPool )
7614 : {
7615 0 : SgWithStatementStorageArray = new SgWithStatementStorageClass[sizeOfActualPool] ;
7616 0 : unsigned long storageClassIndex = SgWithStatement::initializeStorageClassArray (SgWithStatementStorageArray); ;
7617 0 : assert ( storageClassIndex == sizeOfActualPool );
7618 : }
7619 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWcharVal ) ;
7620 0 : std::cout << " SgWcharVal has size " << sizeOfActualPool << std::endl;
7621 0 : SgWcharValStorageClass* SgWcharValStorageArray = NULL;
7622 0 : if ( 0 < sizeOfActualPool )
7623 : {
7624 0 : SgWcharValStorageArray = new SgWcharValStorageClass[sizeOfActualPool] ;
7625 0 : unsigned long storageClassIndex = SgWcharVal::initializeStorageClassArray (SgWcharValStorageArray); ;
7626 0 : assert ( storageClassIndex == sizeOfActualPool );
7627 : }
7628 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWhereStatement ) ;
7629 0 : std::cout << " SgWhereStatement has size " << sizeOfActualPool << std::endl;
7630 0 : SgWhereStatementStorageClass* SgWhereStatementStorageArray = NULL;
7631 0 : if ( 0 < sizeOfActualPool )
7632 : {
7633 0 : SgWhereStatementStorageArray = new SgWhereStatementStorageClass[sizeOfActualPool] ;
7634 0 : unsigned long storageClassIndex = SgWhereStatement::initializeStorageClassArray (SgWhereStatementStorageArray); ;
7635 0 : assert ( storageClassIndex == sizeOfActualPool );
7636 : }
7637 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWhileStmt ) ;
7638 0 : std::cout << " SgWhileStmt has size " << sizeOfActualPool << std::endl;
7639 0 : SgWhileStmtStorageClass* SgWhileStmtStorageArray = NULL;
7640 0 : if ( 0 < sizeOfActualPool )
7641 : {
7642 0 : SgWhileStmtStorageArray = new SgWhileStmtStorageClass[sizeOfActualPool] ;
7643 0 : unsigned long storageClassIndex = SgWhileStmt::initializeStorageClassArray (SgWhileStmtStorageArray); ;
7644 0 : assert ( storageClassIndex == sizeOfActualPool );
7645 : }
7646 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgWriteStatement ) ;
7647 0 : std::cout << " SgWriteStatement has size " << sizeOfActualPool << std::endl;
7648 0 : SgWriteStatementStorageClass* SgWriteStatementStorageArray = NULL;
7649 0 : if ( 0 < sizeOfActualPool )
7650 : {
7651 0 : SgWriteStatementStorageArray = new SgWriteStatementStorageClass[sizeOfActualPool] ;
7652 0 : unsigned long storageClassIndex = SgWriteStatement::initializeStorageClassArray (SgWriteStatementStorageArray); ;
7653 0 : assert ( storageClassIndex == sizeOfActualPool );
7654 : }
7655 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgXorAssignOp ) ;
7656 0 : std::cout << " SgXorAssignOp has size " << sizeOfActualPool << std::endl;
7657 0 : SgXorAssignOpStorageClass* SgXorAssignOpStorageArray = NULL;
7658 0 : if ( 0 < sizeOfActualPool )
7659 : {
7660 0 : SgXorAssignOpStorageArray = new SgXorAssignOpStorageClass[sizeOfActualPool] ;
7661 0 : unsigned long storageClassIndex = SgXorAssignOp::initializeStorageClassArray (SgXorAssignOpStorageArray); ;
7662 0 : assert ( storageClassIndex == sizeOfActualPool );
7663 : }
7664 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgYieldExpression ) ;
7665 0 : std::cout << " SgYieldExpression has size " << sizeOfActualPool << std::endl;
7666 0 : SgYieldExpressionStorageClass* SgYieldExpressionStorageArray = NULL;
7667 0 : if ( 0 < sizeOfActualPool )
7668 : {
7669 0 : SgYieldExpressionStorageArray = new SgYieldExpressionStorageClass[sizeOfActualPool] ;
7670 0 : unsigned long storageClassIndex = SgYieldExpression::initializeStorageClassArray (SgYieldExpressionStorageArray); ;
7671 0 : assert ( storageClassIndex == sizeOfActualPool );
7672 : }
7673 0 : sizeOfActualPool = getSizeOfMemoryPool (V_Sg_File_Info ) ;
7674 0 : std::cout << " Sg_File_Info has size " << sizeOfActualPool << std::endl;
7675 0 : Sg_File_InfoStorageClass* Sg_File_InfoStorageArray = NULL;
7676 0 : if ( 0 < sizeOfActualPool )
7677 : {
7678 0 : Sg_File_InfoStorageArray = new Sg_File_InfoStorageClass[sizeOfActualPool] ;
7679 0 : unsigned long storageClassIndex = Sg_File_Info::initializeStorageClassArray (Sg_File_InfoStorageArray); ;
7680 0 : assert ( storageClassIndex == sizeOfActualPool );
7681 : }
7682 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeCAFTeam ) ;
7683 0 : std::cout << " SgTypeCAFTeam has size " << sizeOfActualPool << std::endl;
7684 0 : SgTypeCAFTeamStorageClass* SgTypeCAFTeamStorageArray = NULL;
7685 0 : if ( 0 < sizeOfActualPool )
7686 : {
7687 0 : SgTypeCAFTeamStorageArray = new SgTypeCAFTeamStorageClass[sizeOfActualPool] ;
7688 0 : unsigned long storageClassIndex = SgTypeCAFTeam::initializeStorageClassArray (SgTypeCAFTeamStorageArray); ;
7689 0 : assert ( storageClassIndex == sizeOfActualPool );
7690 : }
7691 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCAFWithTeamStatement ) ;
7692 0 : std::cout << " SgCAFWithTeamStatement has size " << sizeOfActualPool << std::endl;
7693 0 : SgCAFWithTeamStatementStorageClass* SgCAFWithTeamStatementStorageArray = NULL;
7694 0 : if ( 0 < sizeOfActualPool )
7695 : {
7696 0 : SgCAFWithTeamStatementStorageArray = new SgCAFWithTeamStatementStorageClass[sizeOfActualPool] ;
7697 0 : unsigned long storageClassIndex = SgCAFWithTeamStatement::initializeStorageClassArray (SgCAFWithTeamStatementStorageArray); ;
7698 0 : assert ( storageClassIndex == sizeOfActualPool );
7699 : }
7700 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCAFCoExpression ) ;
7701 0 : std::cout << " SgCAFCoExpression has size " << sizeOfActualPool << std::endl;
7702 0 : SgCAFCoExpressionStorageClass* SgCAFCoExpressionStorageArray = NULL;
7703 0 : if ( 0 < sizeOfActualPool )
7704 : {
7705 0 : SgCAFCoExpressionStorageArray = new SgCAFCoExpressionStorageClass[sizeOfActualPool] ;
7706 0 : unsigned long storageClassIndex = SgCAFCoExpression::initializeStorageClassArray (SgCAFCoExpressionStorageArray); ;
7707 0 : assert ( storageClassIndex == sizeOfActualPool );
7708 : }
7709 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgCallExpression ) ;
7710 0 : std::cout << " SgCallExpression has size " << sizeOfActualPool << std::endl;
7711 0 : SgCallExpressionStorageClass* SgCallExpressionStorageArray = NULL;
7712 0 : if ( 0 < sizeOfActualPool )
7713 : {
7714 0 : SgCallExpressionStorageArray = new SgCallExpressionStorageClass[sizeOfActualPool] ;
7715 0 : unsigned long storageClassIndex = SgCallExpression::initializeStorageClassArray (SgCallExpressionStorageArray); ;
7716 0 : assert ( storageClassIndex == sizeOfActualPool );
7717 : }
7718 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgTypeCrayPointer ) ;
7719 0 : std::cout << " SgTypeCrayPointer has size " << sizeOfActualPool << std::endl;
7720 0 : SgTypeCrayPointerStorageClass* SgTypeCrayPointerStorageArray = NULL;
7721 0 : if ( 0 < sizeOfActualPool )
7722 : {
7723 0 : SgTypeCrayPointerStorageArray = new SgTypeCrayPointerStorageClass[sizeOfActualPool] ;
7724 0 : unsigned long storageClassIndex = SgTypeCrayPointer::initializeStorageClassArray (SgTypeCrayPointerStorageArray); ;
7725 0 : assert ( storageClassIndex == sizeOfActualPool );
7726 : }
7727 0 : sizeOfActualPool = getSizeOfMemoryPool (V_SgClassExp ) ;
7728 0 : std::cout << " SgClassExp has size " << sizeOfActualPool << std::endl;
7729 0 : SgClassExpStorageClass* SgClassExpStorageArray = NULL;
7730 0 : if ( 0 < sizeOfActualPool )
7731 : {
7732 0 : SgClassExpStorageArray = new SgClassExpStorageClass[sizeOfActualPool] ;
7733 0 : unsigned long storageClassIndex = SgClassExp::initializeStorageClassArray (SgClassExpStorageArray); ;
7734 0 : assert ( storageClassIndex == sizeOfActualPool );
7735 : }
7736 0 : clearAllMemoryPools();
7737 0 : AstSpecificDataManagingClassStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock ();
7738 0 : actualRebuildAst = new AstSpecificDataManagingClass(staticTemp);
7739 0 : actualRebuildAst->setStaticDataMembersOfIRNodes();
7740 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAccessModifier ) ;
7741 0 : std::cout << " SgAccessModifier has size " << sizeOfActualPool << std::endl;
7742 0 : if ( 0 < sizeOfActualPool )
7743 : {
7744 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7745 : {
7746 0 : new SgAccessModifier ( SgAccessModifierStorageArray[i] ) ;
7747 : }
7748 0 : delete [] SgAccessModifierStorageArray;
7749 : }
7750 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgActualArgumentExpression ) ;
7751 0 : std::cout << " SgActualArgumentExpression has size " << sizeOfActualPool << std::endl;
7752 0 : if ( 0 < sizeOfActualPool )
7753 : {
7754 0 : SgActualArgumentExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7755 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7756 : {
7757 0 : new SgActualArgumentExpression ( SgActualArgumentExpressionStorageArray[i] ) ;
7758 : }
7759 0 : delete [] SgActualArgumentExpressionStorageArray;
7760 : }
7761 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAddOp ) ;
7762 0 : std::cout << " SgAddOp has size " << sizeOfActualPool << std::endl;
7763 0 : if ( 0 < sizeOfActualPool )
7764 : {
7765 0 : SgAddOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7766 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7767 : {
7768 0 : new SgAddOp ( SgAddOpStorageArray[i] ) ;
7769 : }
7770 0 : delete [] SgAddOpStorageArray;
7771 : }
7772 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAddressOfOp ) ;
7773 0 : std::cout << " SgAddressOfOp has size " << sizeOfActualPool << std::endl;
7774 0 : if ( 0 < sizeOfActualPool )
7775 : {
7776 0 : SgAddressOfOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7777 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7778 : {
7779 0 : new SgAddressOfOp ( SgAddressOfOpStorageArray[i] ) ;
7780 : }
7781 0 : delete [] SgAddressOfOpStorageArray;
7782 : }
7783 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAggregateInitializer ) ;
7784 0 : std::cout << " SgAggregateInitializer has size " << sizeOfActualPool << std::endl;
7785 0 : if ( 0 < sizeOfActualPool )
7786 : {
7787 0 : SgAggregateInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7788 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7789 : {
7790 0 : new SgAggregateInitializer ( SgAggregateInitializerStorageArray[i] ) ;
7791 : }
7792 0 : delete [] SgAggregateInitializerStorageArray;
7793 : }
7794 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAliasSymbol ) ;
7795 0 : std::cout << " SgAliasSymbol has size " << sizeOfActualPool << std::endl;
7796 0 : if ( 0 < sizeOfActualPool )
7797 : {
7798 0 : SgAliasSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7799 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7800 : {
7801 0 : new SgAliasSymbol ( SgAliasSymbolStorageArray[i] ) ;
7802 : }
7803 0 : delete [] SgAliasSymbolStorageArray;
7804 : }
7805 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAllocateStatement ) ;
7806 0 : std::cout << " SgAllocateStatement has size " << sizeOfActualPool << std::endl;
7807 0 : if ( 0 < sizeOfActualPool )
7808 : {
7809 0 : SgAllocateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7810 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7811 : {
7812 0 : new SgAllocateStatement ( SgAllocateStatementStorageArray[i] ) ;
7813 : }
7814 0 : delete [] SgAllocateStatementStorageArray;
7815 : }
7816 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAndAssignOp ) ;
7817 0 : std::cout << " SgAndAssignOp has size " << sizeOfActualPool << std::endl;
7818 0 : if ( 0 < sizeOfActualPool )
7819 : {
7820 0 : SgAndAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7821 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7822 : {
7823 0 : new SgAndAssignOp ( SgAndAssignOpStorageArray[i] ) ;
7824 : }
7825 0 : delete [] SgAndAssignOpStorageArray;
7826 : }
7827 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAndOp ) ;
7828 0 : std::cout << " SgAndOp has size " << sizeOfActualPool << std::endl;
7829 0 : if ( 0 < sizeOfActualPool )
7830 : {
7831 0 : SgAndOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7832 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7833 : {
7834 0 : new SgAndOp ( SgAndOpStorageArray[i] ) ;
7835 : }
7836 0 : delete [] SgAndOpStorageArray;
7837 : }
7838 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgArithmeticIfStatement ) ;
7839 0 : std::cout << " SgArithmeticIfStatement has size " << sizeOfActualPool << std::endl;
7840 0 : if ( 0 < sizeOfActualPool )
7841 : {
7842 0 : SgArithmeticIfStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7843 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7844 : {
7845 0 : new SgArithmeticIfStatement ( SgArithmeticIfStatementStorageArray[i] ) ;
7846 : }
7847 0 : delete [] SgArithmeticIfStatementStorageArray;
7848 : }
7849 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgArrayType ) ;
7850 0 : std::cout << " SgArrayType has size " << sizeOfActualPool << std::endl;
7851 0 : if ( 0 < sizeOfActualPool )
7852 : {
7853 0 : SgArrayTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7854 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7855 : {
7856 0 : new SgArrayType ( SgArrayTypeStorageArray[i] ) ;
7857 : }
7858 0 : delete [] SgArrayTypeStorageArray;
7859 : }
7860 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgArrowExp ) ;
7861 0 : std::cout << " SgArrowExp has size " << sizeOfActualPool << std::endl;
7862 0 : if ( 0 < sizeOfActualPool )
7863 : {
7864 0 : SgArrowExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7865 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7866 : {
7867 0 : new SgArrowExp ( SgArrowExpStorageArray[i] ) ;
7868 : }
7869 0 : delete [] SgArrowExpStorageArray;
7870 : }
7871 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgArrowStarOp ) ;
7872 0 : std::cout << " SgArrowStarOp has size " << sizeOfActualPool << std::endl;
7873 0 : if ( 0 < sizeOfActualPool )
7874 : {
7875 0 : SgArrowStarOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7876 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7877 : {
7878 0 : new SgArrowStarOp ( SgArrowStarOpStorageArray[i] ) ;
7879 : }
7880 0 : delete [] SgArrowStarOpStorageArray;
7881 : }
7882 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAsmOp ) ;
7883 0 : std::cout << " SgAsmOp has size " << sizeOfActualPool << std::endl;
7884 0 : if ( 0 < sizeOfActualPool )
7885 : {
7886 0 : SgAsmOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7887 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7888 : {
7889 0 : new SgAsmOp ( SgAsmOpStorageArray[i] ) ;
7890 : }
7891 0 : delete [] SgAsmOpStorageArray;
7892 : }
7893 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAsmStmt ) ;
7894 0 : std::cout << " SgAsmStmt has size " << sizeOfActualPool << std::endl;
7895 0 : if ( 0 < sizeOfActualPool )
7896 : {
7897 0 : SgAsmStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7898 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7899 : {
7900 0 : new SgAsmStmt ( SgAsmStmtStorageArray[i] ) ;
7901 : }
7902 0 : delete [] SgAsmStmtStorageArray;
7903 : }
7904 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssertStmt ) ;
7905 0 : std::cout << " SgAssertStmt has size " << sizeOfActualPool << std::endl;
7906 0 : if ( 0 < sizeOfActualPool )
7907 : {
7908 0 : SgAssertStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7909 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7910 : {
7911 0 : new SgAssertStmt ( SgAssertStmtStorageArray[i] ) ;
7912 : }
7913 0 : delete [] SgAssertStmtStorageArray;
7914 : }
7915 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssignInitializer ) ;
7916 0 : std::cout << " SgAssignInitializer has size " << sizeOfActualPool << std::endl;
7917 0 : if ( 0 < sizeOfActualPool )
7918 : {
7919 0 : SgAssignInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7920 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7921 : {
7922 0 : new SgAssignInitializer ( SgAssignInitializerStorageArray[i] ) ;
7923 : }
7924 0 : delete [] SgAssignInitializerStorageArray;
7925 : }
7926 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssignOp ) ;
7927 0 : std::cout << " SgAssignOp has size " << sizeOfActualPool << std::endl;
7928 0 : if ( 0 < sizeOfActualPool )
7929 : {
7930 0 : SgAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7931 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7932 : {
7933 0 : new SgAssignOp ( SgAssignOpStorageArray[i] ) ;
7934 : }
7935 0 : delete [] SgAssignOpStorageArray;
7936 : }
7937 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssignStatement ) ;
7938 0 : std::cout << " SgAssignStatement has size " << sizeOfActualPool << std::endl;
7939 0 : if ( 0 < sizeOfActualPool )
7940 : {
7941 0 : SgAssignStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7942 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7943 : {
7944 0 : new SgAssignStatement ( SgAssignStatementStorageArray[i] ) ;
7945 : }
7946 0 : delete [] SgAssignStatementStorageArray;
7947 : }
7948 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssignedGotoStatement ) ;
7949 0 : std::cout << " SgAssignedGotoStatement has size " << sizeOfActualPool << std::endl;
7950 0 : if ( 0 < sizeOfActualPool )
7951 : {
7952 0 : SgAssignedGotoStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7953 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7954 : {
7955 0 : new SgAssignedGotoStatement ( SgAssignedGotoStatementStorageArray[i] ) ;
7956 : }
7957 0 : delete [] SgAssignedGotoStatementStorageArray;
7958 : }
7959 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAssociateStatement ) ;
7960 0 : std::cout << " SgAssociateStatement has size " << sizeOfActualPool << std::endl;
7961 0 : if ( 0 < sizeOfActualPool )
7962 : {
7963 0 : SgAssociateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7964 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7965 : {
7966 0 : new SgAssociateStatement ( SgAssociateStatementStorageArray[i] ) ;
7967 : }
7968 0 : delete [] SgAssociateStatementStorageArray;
7969 : }
7970 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAsteriskShapeExp ) ;
7971 0 : std::cout << " SgAsteriskShapeExp has size " << sizeOfActualPool << std::endl;
7972 0 : if ( 0 < sizeOfActualPool )
7973 : {
7974 0 : SgAsteriskShapeExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7975 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7976 : {
7977 0 : new SgAsteriskShapeExp ( SgAsteriskShapeExpStorageArray[i] ) ;
7978 : }
7979 0 : delete [] SgAsteriskShapeExpStorageArray;
7980 : }
7981 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAttribute ) ;
7982 0 : std::cout << " SgAttribute has size " << sizeOfActualPool << std::endl;
7983 0 : if ( 0 < sizeOfActualPool )
7984 : {
7985 0 : SgAttributeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7986 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7987 : {
7988 0 : new SgAttribute ( SgAttributeStorageArray[i] ) ;
7989 : }
7990 0 : delete [] SgAttributeStorageArray;
7991 : }
7992 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAttributeSpecificationStatement ) ;
7993 0 : std::cout << " SgAttributeSpecificationStatement has size " << sizeOfActualPool << std::endl;
7994 0 : if ( 0 < sizeOfActualPool )
7995 : {
7996 0 : SgAttributeSpecificationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
7997 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
7998 : {
7999 0 : new SgAttributeSpecificationStatement ( SgAttributeSpecificationStatementStorageArray[i] ) ;
8000 : }
8001 0 : delete [] SgAttributeSpecificationStatementStorageArray;
8002 : }
8003 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAutoType ) ;
8004 0 : std::cout << " SgAutoType has size " << sizeOfActualPool << std::endl;
8005 0 : if ( 0 < sizeOfActualPool )
8006 : {
8007 0 : SgAutoTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8008 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8009 : {
8010 0 : new SgAutoType ( SgAutoTypeStorageArray[i] ) ;
8011 : }
8012 0 : delete [] SgAutoTypeStorageArray;
8013 : }
8014 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAwaitExpression ) ;
8015 0 : std::cout << " SgAwaitExpression has size " << sizeOfActualPool << std::endl;
8016 0 : if ( 0 < sizeOfActualPool )
8017 : {
8018 0 : SgAwaitExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8019 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8020 : {
8021 0 : new SgAwaitExpression ( SgAwaitExpressionStorageArray[i] ) ;
8022 : }
8023 0 : delete [] SgAwaitExpressionStorageArray;
8024 : }
8025 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBackspaceStatement ) ;
8026 0 : std::cout << " SgBackspaceStatement has size " << sizeOfActualPool << std::endl;
8027 0 : if ( 0 < sizeOfActualPool )
8028 : {
8029 0 : SgBackspaceStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8030 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8031 : {
8032 0 : new SgBackspaceStatement ( SgBackspaceStatementStorageArray[i] ) ;
8033 : }
8034 0 : delete [] SgBackspaceStatementStorageArray;
8035 : }
8036 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBaseClass ) ;
8037 0 : std::cout << " SgBaseClass has size " << sizeOfActualPool << std::endl;
8038 0 : if ( 0 < sizeOfActualPool )
8039 : {
8040 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8041 : {
8042 0 : new SgBaseClass ( SgBaseClassStorageArray[i] ) ;
8043 : }
8044 0 : delete [] SgBaseClassStorageArray;
8045 : }
8046 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExpBaseClass ) ;
8047 0 : std::cout << " SgExpBaseClass has size " << sizeOfActualPool << std::endl;
8048 0 : if ( 0 < sizeOfActualPool )
8049 : {
8050 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8051 : {
8052 0 : new SgExpBaseClass ( SgExpBaseClassStorageArray[i] ) ;
8053 : }
8054 0 : delete [] SgExpBaseClassStorageArray;
8055 : }
8056 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBaseClassModifier ) ;
8057 0 : std::cout << " SgBaseClassModifier has size " << sizeOfActualPool << std::endl;
8058 0 : if ( 0 < sizeOfActualPool )
8059 : {
8060 0 : SgBaseClassModifierStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8061 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8062 : {
8063 0 : new SgBaseClassModifier ( SgBaseClassModifierStorageArray[i] ) ;
8064 : }
8065 0 : delete [] SgBaseClassModifierStorageArray;
8066 : }
8067 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBasicBlock ) ;
8068 0 : std::cout << " SgBasicBlock has size " << sizeOfActualPool << std::endl;
8069 0 : if ( 0 < sizeOfActualPool )
8070 : {
8071 0 : SgBasicBlockStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8072 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8073 : {
8074 0 : new SgBasicBlock ( SgBasicBlockStorageArray[i] ) ;
8075 : }
8076 0 : delete [] SgBasicBlockStorageArray;
8077 : }
8078 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBidirectionalGraph ) ;
8079 0 : std::cout << " SgBidirectionalGraph has size " << sizeOfActualPool << std::endl;
8080 0 : if ( 0 < sizeOfActualPool )
8081 : {
8082 0 : SgBidirectionalGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8083 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8084 : {
8085 0 : new SgBidirectionalGraph ( SgBidirectionalGraphStorageArray[i] ) ;
8086 : }
8087 0 : delete [] SgBidirectionalGraphStorageArray;
8088 : }
8089 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBinaryOp ) ;
8090 0 : std::cout << " SgBinaryOp has size " << sizeOfActualPool << std::endl;
8091 0 : if ( 0 < sizeOfActualPool )
8092 : {
8093 0 : SgBinaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8094 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8095 : {
8096 0 : new SgBinaryOp ( SgBinaryOpStorageArray[i] ) ;
8097 : }
8098 0 : delete [] SgBinaryOpStorageArray;
8099 : }
8100 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitAndOp ) ;
8101 0 : std::cout << " SgBitAndOp has size " << sizeOfActualPool << std::endl;
8102 0 : if ( 0 < sizeOfActualPool )
8103 : {
8104 0 : SgBitAndOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8105 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8106 : {
8107 0 : new SgBitAndOp ( SgBitAndOpStorageArray[i] ) ;
8108 : }
8109 0 : delete [] SgBitAndOpStorageArray;
8110 : }
8111 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitAttribute ) ;
8112 0 : std::cout << " SgBitAttribute has size " << sizeOfActualPool << std::endl;
8113 0 : if ( 0 < sizeOfActualPool )
8114 : {
8115 0 : SgBitAttributeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8116 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8117 : {
8118 0 : new SgBitAttribute ( SgBitAttributeStorageArray[i] ) ;
8119 : }
8120 0 : delete [] SgBitAttributeStorageArray;
8121 : }
8122 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitComplementOp ) ;
8123 0 : std::cout << " SgBitComplementOp has size " << sizeOfActualPool << std::endl;
8124 0 : if ( 0 < sizeOfActualPool )
8125 : {
8126 0 : SgBitComplementOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8127 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8128 : {
8129 0 : new SgBitComplementOp ( SgBitComplementOpStorageArray[i] ) ;
8130 : }
8131 0 : delete [] SgBitComplementOpStorageArray;
8132 : }
8133 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitEqvOp ) ;
8134 0 : std::cout << " SgBitEqvOp has size " << sizeOfActualPool << std::endl;
8135 0 : if ( 0 < sizeOfActualPool )
8136 : {
8137 0 : SgBitEqvOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8138 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8139 : {
8140 0 : new SgBitEqvOp ( SgBitEqvOpStorageArray[i] ) ;
8141 : }
8142 0 : delete [] SgBitEqvOpStorageArray;
8143 : }
8144 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitOrOp ) ;
8145 0 : std::cout << " SgBitOrOp has size " << sizeOfActualPool << std::endl;
8146 0 : if ( 0 < sizeOfActualPool )
8147 : {
8148 0 : SgBitOrOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8149 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8150 : {
8151 0 : new SgBitOrOp ( SgBitOrOpStorageArray[i] ) ;
8152 : }
8153 0 : delete [] SgBitOrOpStorageArray;
8154 : }
8155 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBitXorOp ) ;
8156 0 : std::cout << " SgBitXorOp has size " << sizeOfActualPool << std::endl;
8157 0 : if ( 0 < sizeOfActualPool )
8158 : {
8159 0 : SgBitXorOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8160 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8161 : {
8162 0 : new SgBitXorOp ( SgBitXorOpStorageArray[i] ) ;
8163 : }
8164 0 : delete [] SgBitXorOpStorageArray;
8165 : }
8166 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBlockDataStatement ) ;
8167 0 : std::cout << " SgBlockDataStatement has size " << sizeOfActualPool << std::endl;
8168 0 : if ( 0 < sizeOfActualPool )
8169 : {
8170 0 : SgBlockDataStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8171 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8172 : {
8173 0 : new SgBlockDataStatement ( SgBlockDataStatementStorageArray[i] ) ;
8174 : }
8175 0 : delete [] SgBlockDataStatementStorageArray;
8176 : }
8177 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBoolValExp ) ;
8178 0 : std::cout << " SgBoolValExp has size " << sizeOfActualPool << std::endl;
8179 0 : if ( 0 < sizeOfActualPool )
8180 : {
8181 0 : SgBoolValExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8182 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8183 : {
8184 0 : new SgBoolValExp ( SgBoolValExpStorageArray[i] ) ;
8185 : }
8186 0 : delete [] SgBoolValExpStorageArray;
8187 : }
8188 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBreakStmt ) ;
8189 0 : std::cout << " SgBreakStmt has size " << sizeOfActualPool << std::endl;
8190 0 : if ( 0 < sizeOfActualPool )
8191 : {
8192 0 : SgBreakStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8193 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8194 : {
8195 0 : new SgBreakStmt ( SgBreakStmtStorageArray[i] ) ;
8196 : }
8197 0 : delete [] SgBreakStmtStorageArray;
8198 : }
8199 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgBracedInitializer ) ;
8200 0 : std::cout << " SgBracedInitializer has size " << sizeOfActualPool << std::endl;
8201 0 : if ( 0 < sizeOfActualPool )
8202 : {
8203 0 : SgBracedInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8204 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8205 : {
8206 0 : new SgBracedInitializer ( SgBracedInitializerStorageArray[i] ) ;
8207 : }
8208 0 : delete [] SgBracedInitializerStorageArray;
8209 : }
8210 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgC_PreprocessorDirectiveStatement ) ;
8211 0 : std::cout << " SgC_PreprocessorDirectiveStatement has size " << sizeOfActualPool << std::endl;
8212 0 : if ( 0 < sizeOfActualPool )
8213 : {
8214 0 : SgC_PreprocessorDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8215 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8216 : {
8217 0 : new SgC_PreprocessorDirectiveStatement ( SgC_PreprocessorDirectiveStatementStorageArray[i] ) ;
8218 : }
8219 0 : delete [] SgC_PreprocessorDirectiveStatementStorageArray;
8220 : }
8221 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCaseOptionStmt ) ;
8222 0 : std::cout << " SgCaseOptionStmt has size " << sizeOfActualPool << std::endl;
8223 0 : if ( 0 < sizeOfActualPool )
8224 : {
8225 0 : SgCaseOptionStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8226 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8227 : {
8228 0 : new SgCaseOptionStmt ( SgCaseOptionStmtStorageArray[i] ) ;
8229 : }
8230 0 : delete [] SgCaseOptionStmtStorageArray;
8231 : }
8232 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCastExp ) ;
8233 0 : std::cout << " SgCastExp has size " << sizeOfActualPool << std::endl;
8234 0 : if ( 0 < sizeOfActualPool )
8235 : {
8236 0 : SgCastExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8237 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8238 : {
8239 0 : new SgCastExp ( SgCastExpStorageArray[i] ) ;
8240 : }
8241 0 : delete [] SgCastExpStorageArray;
8242 : }
8243 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCatchOptionStmt ) ;
8244 0 : std::cout << " SgCatchOptionStmt has size " << sizeOfActualPool << std::endl;
8245 0 : if ( 0 < sizeOfActualPool )
8246 : {
8247 0 : SgCatchOptionStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8248 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8249 : {
8250 0 : new SgCatchOptionStmt ( SgCatchOptionStmtStorageArray[i] ) ;
8251 : }
8252 0 : delete [] SgCatchOptionStmtStorageArray;
8253 : }
8254 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCatchStatementSeq ) ;
8255 0 : std::cout << " SgCatchStatementSeq has size " << sizeOfActualPool << std::endl;
8256 0 : if ( 0 < sizeOfActualPool )
8257 : {
8258 0 : SgCatchStatementSeqStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8259 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8260 : {
8261 0 : new SgCatchStatementSeq ( SgCatchStatementSeqStorageArray[i] ) ;
8262 : }
8263 0 : delete [] SgCatchStatementSeqStorageArray;
8264 : }
8265 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCharVal ) ;
8266 0 : std::cout << " SgCharVal has size " << sizeOfActualPool << std::endl;
8267 0 : if ( 0 < sizeOfActualPool )
8268 : {
8269 0 : SgCharValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8270 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8271 : {
8272 0 : new SgCharVal ( SgCharValStorageArray[i] ) ;
8273 : }
8274 0 : delete [] SgCharValStorageArray;
8275 : }
8276 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgChar16Val ) ;
8277 0 : std::cout << " SgChar16Val has size " << sizeOfActualPool << std::endl;
8278 0 : if ( 0 < sizeOfActualPool )
8279 : {
8280 0 : SgChar16ValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8281 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8282 : {
8283 0 : new SgChar16Val ( SgChar16ValStorageArray[i] ) ;
8284 : }
8285 0 : delete [] SgChar16ValStorageArray;
8286 : }
8287 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgChar32Val ) ;
8288 0 : std::cout << " SgChar32Val has size " << sizeOfActualPool << std::endl;
8289 0 : if ( 0 < sizeOfActualPool )
8290 : {
8291 0 : SgChar32ValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8292 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8293 : {
8294 0 : new SgChar32Val ( SgChar32ValStorageArray[i] ) ;
8295 : }
8296 0 : delete [] SgChar32ValStorageArray;
8297 : }
8298 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgChooseExpression ) ;
8299 0 : std::cout << " SgChooseExpression has size " << sizeOfActualPool << std::endl;
8300 0 : if ( 0 < sizeOfActualPool )
8301 : {
8302 0 : SgChooseExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8303 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8304 : {
8305 0 : new SgChooseExpression ( SgChooseExpressionStorageArray[i] ) ;
8306 : }
8307 0 : delete [] SgChooseExpressionStorageArray;
8308 : }
8309 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassDecl_attr ) ;
8310 0 : std::cout << " SgClassDecl_attr has size " << sizeOfActualPool << std::endl;
8311 0 : if ( 0 < sizeOfActualPool )
8312 : {
8313 0 : SgClassDecl_attrStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8314 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8315 : {
8316 0 : new SgClassDecl_attr ( SgClassDecl_attrStorageArray[i] ) ;
8317 : }
8318 0 : delete [] SgClassDecl_attrStorageArray;
8319 : }
8320 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassDeclaration ) ;
8321 0 : std::cout << " SgClassDeclaration has size " << sizeOfActualPool << std::endl;
8322 0 : if ( 0 < sizeOfActualPool )
8323 : {
8324 0 : SgClassDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8325 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8326 : {
8327 0 : new SgClassDeclaration ( SgClassDeclarationStorageArray[i] ) ;
8328 : }
8329 0 : delete [] SgClassDeclarationStorageArray;
8330 : }
8331 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassDefinition ) ;
8332 0 : std::cout << " SgClassDefinition has size " << sizeOfActualPool << std::endl;
8333 0 : if ( 0 < sizeOfActualPool )
8334 : {
8335 0 : SgClassDefinitionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8336 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8337 : {
8338 0 : new SgClassDefinition ( SgClassDefinitionStorageArray[i] ) ;
8339 : }
8340 0 : delete [] SgClassDefinitionStorageArray;
8341 : }
8342 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassNameRefExp ) ;
8343 0 : std::cout << " SgClassNameRefExp has size " << sizeOfActualPool << std::endl;
8344 0 : if ( 0 < sizeOfActualPool )
8345 : {
8346 0 : SgClassNameRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8347 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8348 : {
8349 0 : new SgClassNameRefExp ( SgClassNameRefExpStorageArray[i] ) ;
8350 : }
8351 0 : delete [] SgClassNameRefExpStorageArray;
8352 : }
8353 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassSymbol ) ;
8354 0 : std::cout << " SgClassSymbol has size " << sizeOfActualPool << std::endl;
8355 0 : if ( 0 < sizeOfActualPool )
8356 : {
8357 0 : SgClassSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8358 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8359 : {
8360 0 : new SgClassSymbol ( SgClassSymbolStorageArray[i] ) ;
8361 : }
8362 0 : delete [] SgClassSymbolStorageArray;
8363 : }
8364 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassType ) ;
8365 0 : std::cout << " SgClassType has size " << sizeOfActualPool << std::endl;
8366 0 : if ( 0 < sizeOfActualPool )
8367 : {
8368 0 : SgClassTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8369 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8370 : {
8371 0 : new SgClassType ( SgClassTypeStorageArray[i] ) ;
8372 : }
8373 0 : delete [] SgClassTypeStorageArray;
8374 : }
8375 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClinkageDeclarationStatement ) ;
8376 0 : std::cout << " SgClinkageDeclarationStatement has size " << sizeOfActualPool << std::endl;
8377 0 : if ( 0 < sizeOfActualPool )
8378 : {
8379 0 : SgClinkageDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8380 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8381 : {
8382 0 : new SgClinkageDeclarationStatement ( SgClinkageDeclarationStatementStorageArray[i] ) ;
8383 : }
8384 0 : delete [] SgClinkageDeclarationStatementStorageArray;
8385 : }
8386 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClinkageEndStatement ) ;
8387 0 : std::cout << " SgClinkageEndStatement has size " << sizeOfActualPool << std::endl;
8388 0 : if ( 0 < sizeOfActualPool )
8389 : {
8390 0 : SgClinkageEndStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8391 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8392 : {
8393 0 : new SgClinkageEndStatement ( SgClinkageEndStatementStorageArray[i] ) ;
8394 : }
8395 0 : delete [] SgClinkageEndStatementStorageArray;
8396 : }
8397 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClinkageStartStatement ) ;
8398 0 : std::cout << " SgClinkageStartStatement has size " << sizeOfActualPool << std::endl;
8399 0 : if ( 0 < sizeOfActualPool )
8400 : {
8401 0 : SgClinkageStartStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8402 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8403 : {
8404 0 : new SgClinkageStartStatement ( SgClinkageStartStatementStorageArray[i] ) ;
8405 : }
8406 0 : delete [] SgClinkageStartStatementStorageArray;
8407 : }
8408 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCloseStatement ) ;
8409 0 : std::cout << " SgCloseStatement has size " << sizeOfActualPool << std::endl;
8410 0 : if ( 0 < sizeOfActualPool )
8411 : {
8412 0 : SgCloseStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8413 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8414 : {
8415 0 : new SgCloseStatement ( SgCloseStatementStorageArray[i] ) ;
8416 : }
8417 0 : delete [] SgCloseStatementStorageArray;
8418 : }
8419 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgColonShapeExp ) ;
8420 0 : std::cout << " SgColonShapeExp has size " << sizeOfActualPool << std::endl;
8421 0 : if ( 0 < sizeOfActualPool )
8422 : {
8423 0 : SgColonShapeExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8424 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8425 : {
8426 0 : new SgColonShapeExp ( SgColonShapeExpStorageArray[i] ) ;
8427 : }
8428 0 : delete [] SgColonShapeExpStorageArray;
8429 : }
8430 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCommaOpExp ) ;
8431 0 : std::cout << " SgCommaOpExp has size " << sizeOfActualPool << std::endl;
8432 0 : if ( 0 < sizeOfActualPool )
8433 : {
8434 0 : SgCommaOpExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8435 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8436 : {
8437 0 : new SgCommaOpExp ( SgCommaOpExpStorageArray[i] ) ;
8438 : }
8439 0 : delete [] SgCommaOpExpStorageArray;
8440 : }
8441 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCommonBlock ) ;
8442 0 : std::cout << " SgCommonBlock has size " << sizeOfActualPool << std::endl;
8443 0 : if ( 0 < sizeOfActualPool )
8444 : {
8445 0 : SgCommonBlockStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8446 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8447 : {
8448 0 : new SgCommonBlock ( SgCommonBlockStorageArray[i] ) ;
8449 : }
8450 0 : delete [] SgCommonBlockStorageArray;
8451 : }
8452 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCommonBlockObject ) ;
8453 0 : std::cout << " SgCommonBlockObject has size " << sizeOfActualPool << std::endl;
8454 0 : if ( 0 < sizeOfActualPool )
8455 : {
8456 0 : SgCommonBlockObjectStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8457 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8458 : {
8459 0 : new SgCommonBlockObject ( SgCommonBlockObjectStorageArray[i] ) ;
8460 : }
8461 0 : delete [] SgCommonBlockObjectStorageArray;
8462 : }
8463 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCommonSymbol ) ;
8464 0 : std::cout << " SgCommonSymbol has size " << sizeOfActualPool << std::endl;
8465 0 : if ( 0 < sizeOfActualPool )
8466 : {
8467 0 : SgCommonSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8468 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8469 : {
8470 0 : new SgCommonSymbol ( SgCommonSymbolStorageArray[i] ) ;
8471 : }
8472 0 : delete [] SgCommonSymbolStorageArray;
8473 : }
8474 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgComplexVal ) ;
8475 0 : std::cout << " SgComplexVal has size " << sizeOfActualPool << std::endl;
8476 0 : if ( 0 < sizeOfActualPool )
8477 : {
8478 0 : SgComplexValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8479 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8480 : {
8481 0 : new SgComplexVal ( SgComplexValStorageArray[i] ) ;
8482 : }
8483 0 : delete [] SgComplexValStorageArray;
8484 : }
8485 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgComprehension ) ;
8486 0 : std::cout << " SgComprehension has size " << sizeOfActualPool << std::endl;
8487 0 : if ( 0 < sizeOfActualPool )
8488 : {
8489 0 : SgComprehensionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8490 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8491 : {
8492 0 : new SgComprehension ( SgComprehensionStorageArray[i] ) ;
8493 : }
8494 0 : delete [] SgComprehensionStorageArray;
8495 : }
8496 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCompoundAssignOp ) ;
8497 0 : std::cout << " SgCompoundAssignOp has size " << sizeOfActualPool << std::endl;
8498 0 : if ( 0 < sizeOfActualPool )
8499 : {
8500 0 : SgCompoundAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8501 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8502 : {
8503 0 : new SgCompoundAssignOp ( SgCompoundAssignOpStorageArray[i] ) ;
8504 : }
8505 0 : delete [] SgCompoundAssignOpStorageArray;
8506 : }
8507 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCompoundInitializer ) ;
8508 0 : std::cout << " SgCompoundInitializer has size " << sizeOfActualPool << std::endl;
8509 0 : if ( 0 < sizeOfActualPool )
8510 : {
8511 0 : SgCompoundInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8512 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8513 : {
8514 0 : new SgCompoundInitializer ( SgCompoundInitializerStorageArray[i] ) ;
8515 : }
8516 0 : delete [] SgCompoundInitializerStorageArray;
8517 : }
8518 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCompoundLiteralExp ) ;
8519 0 : std::cout << " SgCompoundLiteralExp has size " << sizeOfActualPool << std::endl;
8520 0 : if ( 0 < sizeOfActualPool )
8521 : {
8522 0 : SgCompoundLiteralExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8523 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8524 : {
8525 0 : new SgCompoundLiteralExp ( SgCompoundLiteralExpStorageArray[i] ) ;
8526 : }
8527 0 : delete [] SgCompoundLiteralExpStorageArray;
8528 : }
8529 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgComputedGotoStatement ) ;
8530 0 : std::cout << " SgComputedGotoStatement has size " << sizeOfActualPool << std::endl;
8531 0 : if ( 0 < sizeOfActualPool )
8532 : {
8533 0 : SgComputedGotoStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8534 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8535 : {
8536 0 : new SgComputedGotoStatement ( SgComputedGotoStatementStorageArray[i] ) ;
8537 : }
8538 0 : delete [] SgComputedGotoStatementStorageArray;
8539 : }
8540 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgConcatenationOp ) ;
8541 0 : std::cout << " SgConcatenationOp has size " << sizeOfActualPool << std::endl;
8542 0 : if ( 0 < sizeOfActualPool )
8543 : {
8544 0 : SgConcatenationOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8545 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8546 : {
8547 0 : new SgConcatenationOp ( SgConcatenationOpStorageArray[i] ) ;
8548 : }
8549 0 : delete [] SgConcatenationOpStorageArray;
8550 : }
8551 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgConditionalExp ) ;
8552 0 : std::cout << " SgConditionalExp has size " << sizeOfActualPool << std::endl;
8553 0 : if ( 0 < sizeOfActualPool )
8554 : {
8555 0 : SgConditionalExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8556 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8557 : {
8558 0 : new SgConditionalExp ( SgConditionalExpStorageArray[i] ) ;
8559 : }
8560 0 : delete [] SgConditionalExpStorageArray;
8561 : }
8562 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgConjugateOp ) ;
8563 0 : std::cout << " SgConjugateOp has size " << sizeOfActualPool << std::endl;
8564 0 : if ( 0 < sizeOfActualPool )
8565 : {
8566 0 : SgConjugateOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8567 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8568 : {
8569 0 : new SgConjugateOp ( SgConjugateOpStorageArray[i] ) ;
8570 : }
8571 0 : delete [] SgConjugateOpStorageArray;
8572 : }
8573 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgConstVolatileModifier ) ;
8574 0 : std::cout << " SgConstVolatileModifier has size " << sizeOfActualPool << std::endl;
8575 0 : if ( 0 < sizeOfActualPool )
8576 : {
8577 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8578 : {
8579 0 : new SgConstVolatileModifier ( SgConstVolatileModifierStorageArray[i] ) ;
8580 : }
8581 0 : delete [] SgConstVolatileModifierStorageArray;
8582 : }
8583 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgConstructorInitializer ) ;
8584 0 : std::cout << " SgConstructorInitializer has size " << sizeOfActualPool << std::endl;
8585 0 : if ( 0 < sizeOfActualPool )
8586 : {
8587 0 : SgConstructorInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8588 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8589 : {
8590 0 : new SgConstructorInitializer ( SgConstructorInitializerStorageArray[i] ) ;
8591 : }
8592 0 : delete [] SgConstructorInitializerStorageArray;
8593 : }
8594 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgContainsStatement ) ;
8595 0 : std::cout << " SgContainsStatement has size " << sizeOfActualPool << std::endl;
8596 0 : if ( 0 < sizeOfActualPool )
8597 : {
8598 0 : SgContainsStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8599 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8600 : {
8601 0 : new SgContainsStatement ( SgContainsStatementStorageArray[i] ) ;
8602 : }
8603 0 : delete [] SgContainsStatementStorageArray;
8604 : }
8605 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgContinueStmt ) ;
8606 0 : std::cout << " SgContinueStmt has size " << sizeOfActualPool << std::endl;
8607 0 : if ( 0 < sizeOfActualPool )
8608 : {
8609 0 : SgContinueStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8610 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8611 : {
8612 0 : new SgContinueStmt ( SgContinueStmtStorageArray[i] ) ;
8613 : }
8614 0 : delete [] SgContinueStmtStorageArray;
8615 : }
8616 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCtorInitializerList ) ;
8617 0 : std::cout << " SgCtorInitializerList has size " << sizeOfActualPool << std::endl;
8618 0 : if ( 0 < sizeOfActualPool )
8619 : {
8620 0 : SgCtorInitializerListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8621 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8622 : {
8623 0 : new SgCtorInitializerList ( SgCtorInitializerListStorageArray[i] ) ;
8624 : }
8625 0 : delete [] SgCtorInitializerListStorageArray;
8626 : }
8627 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDataStatementGroup ) ;
8628 0 : std::cout << " SgDataStatementGroup has size " << sizeOfActualPool << std::endl;
8629 0 : if ( 0 < sizeOfActualPool )
8630 : {
8631 0 : SgDataStatementGroupStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8632 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8633 : {
8634 0 : new SgDataStatementGroup ( SgDataStatementGroupStorageArray[i] ) ;
8635 : }
8636 0 : delete [] SgDataStatementGroupStorageArray;
8637 : }
8638 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDataStatementObject ) ;
8639 0 : std::cout << " SgDataStatementObject has size " << sizeOfActualPool << std::endl;
8640 0 : if ( 0 < sizeOfActualPool )
8641 : {
8642 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8643 : {
8644 0 : new SgDataStatementObject ( SgDataStatementObjectStorageArray[i] ) ;
8645 : }
8646 0 : delete [] SgDataStatementObjectStorageArray;
8647 : }
8648 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDataStatementValue ) ;
8649 0 : std::cout << " SgDataStatementValue has size " << sizeOfActualPool << std::endl;
8650 0 : if ( 0 < sizeOfActualPool )
8651 : {
8652 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8653 : {
8654 0 : new SgDataStatementValue ( SgDataStatementValueStorageArray[i] ) ;
8655 : }
8656 0 : delete [] SgDataStatementValueStorageArray;
8657 : }
8658 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeadIfDirectiveStatement ) ;
8659 0 : std::cout << " SgDeadIfDirectiveStatement has size " << sizeOfActualPool << std::endl;
8660 0 : if ( 0 < sizeOfActualPool )
8661 : {
8662 0 : SgDeadIfDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8663 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8664 : {
8665 0 : new SgDeadIfDirectiveStatement ( SgDeadIfDirectiveStatementStorageArray[i] ) ;
8666 : }
8667 0 : delete [] SgDeadIfDirectiveStatementStorageArray;
8668 : }
8669 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeallocateStatement ) ;
8670 0 : std::cout << " SgDeallocateStatement has size " << sizeOfActualPool << std::endl;
8671 0 : if ( 0 < sizeOfActualPool )
8672 : {
8673 0 : SgDeallocateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8674 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8675 : {
8676 0 : new SgDeallocateStatement ( SgDeallocateStatementStorageArray[i] ) ;
8677 : }
8678 0 : delete [] SgDeallocateStatementStorageArray;
8679 : }
8680 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeclarationModifier ) ;
8681 0 : std::cout << " SgDeclarationModifier has size " << sizeOfActualPool << std::endl;
8682 0 : if ( 0 < sizeOfActualPool )
8683 : {
8684 0 : SgDeclarationModifierStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8685 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8686 : {
8687 0 : new SgDeclarationModifier ( SgDeclarationModifierStorageArray[i] ) ;
8688 : }
8689 0 : delete [] SgDeclarationModifierStorageArray;
8690 : }
8691 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeclarationScope ) ;
8692 0 : std::cout << " SgDeclarationScope has size " << sizeOfActualPool << std::endl;
8693 0 : if ( 0 < sizeOfActualPool )
8694 : {
8695 0 : SgDeclarationScopeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8696 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8697 : {
8698 0 : new SgDeclarationScope ( SgDeclarationScopeStorageArray[i] ) ;
8699 : }
8700 0 : delete [] SgDeclarationScopeStorageArray;
8701 : }
8702 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeclarationStatement ) ;
8703 0 : std::cout << " SgDeclarationStatement has size " << sizeOfActualPool << std::endl;
8704 0 : if ( 0 < sizeOfActualPool )
8705 : {
8706 0 : SgDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8707 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8708 : {
8709 0 : new SgDeclarationStatement ( SgDeclarationStatementStorageArray[i] ) ;
8710 : }
8711 0 : delete [] SgDeclarationStatementStorageArray;
8712 : }
8713 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeclType ) ;
8714 0 : std::cout << " SgDeclType has size " << sizeOfActualPool << std::endl;
8715 0 : if ( 0 < sizeOfActualPool )
8716 : {
8717 0 : SgDeclTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8718 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8719 : {
8720 0 : new SgDeclType ( SgDeclTypeStorageArray[i] ) ;
8721 : }
8722 0 : delete [] SgDeclTypeStorageArray;
8723 : }
8724 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDefaultOptionStmt ) ;
8725 0 : std::cout << " SgDefaultOptionStmt has size " << sizeOfActualPool << std::endl;
8726 0 : if ( 0 < sizeOfActualPool )
8727 : {
8728 0 : SgDefaultOptionStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8729 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8730 : {
8731 0 : new SgDefaultOptionStmt ( SgDefaultOptionStmtStorageArray[i] ) ;
8732 : }
8733 0 : delete [] SgDefaultOptionStmtStorageArray;
8734 : }
8735 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDefaultSymbol ) ;
8736 0 : std::cout << " SgDefaultSymbol has size " << sizeOfActualPool << std::endl;
8737 0 : if ( 0 < sizeOfActualPool )
8738 : {
8739 0 : SgDefaultSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8740 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8741 : {
8742 0 : new SgDefaultSymbol ( SgDefaultSymbolStorageArray[i] ) ;
8743 : }
8744 0 : delete [] SgDefaultSymbolStorageArray;
8745 : }
8746 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDefineDirectiveStatement ) ;
8747 0 : std::cout << " SgDefineDirectiveStatement has size " << sizeOfActualPool << std::endl;
8748 0 : if ( 0 < sizeOfActualPool )
8749 : {
8750 0 : SgDefineDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8751 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8752 : {
8753 0 : new SgDefineDirectiveStatement ( SgDefineDirectiveStatementStorageArray[i] ) ;
8754 : }
8755 0 : delete [] SgDefineDirectiveStatementStorageArray;
8756 : }
8757 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDeleteExp ) ;
8758 0 : std::cout << " SgDeleteExp has size " << sizeOfActualPool << std::endl;
8759 0 : if ( 0 < sizeOfActualPool )
8760 : {
8761 0 : SgDeleteExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8762 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8763 : {
8764 0 : new SgDeleteExp ( SgDeleteExpStorageArray[i] ) ;
8765 : }
8766 0 : delete [] SgDeleteExpStorageArray;
8767 : }
8768 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDerivedTypeStatement ) ;
8769 0 : std::cout << " SgDerivedTypeStatement has size " << sizeOfActualPool << std::endl;
8770 0 : if ( 0 < sizeOfActualPool )
8771 : {
8772 0 : SgDerivedTypeStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8773 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8774 : {
8775 0 : new SgDerivedTypeStatement ( SgDerivedTypeStatementStorageArray[i] ) ;
8776 : }
8777 0 : delete [] SgDerivedTypeStatementStorageArray;
8778 : }
8779 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDesignatedInitializer ) ;
8780 0 : std::cout << " SgDesignatedInitializer has size " << sizeOfActualPool << std::endl;
8781 0 : if ( 0 < sizeOfActualPool )
8782 : {
8783 0 : SgDesignatedInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8784 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8785 : {
8786 0 : new SgDesignatedInitializer ( SgDesignatedInitializerStorageArray[i] ) ;
8787 : }
8788 0 : delete [] SgDesignatedInitializerStorageArray;
8789 : }
8790 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDictionaryComprehension ) ;
8791 0 : std::cout << " SgDictionaryComprehension has size " << sizeOfActualPool << std::endl;
8792 0 : if ( 0 < sizeOfActualPool )
8793 : {
8794 0 : SgDictionaryComprehensionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8795 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8796 : {
8797 0 : new SgDictionaryComprehension ( SgDictionaryComprehensionStorageArray[i] ) ;
8798 : }
8799 0 : delete [] SgDictionaryComprehensionStorageArray;
8800 : }
8801 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDictionaryExp ) ;
8802 0 : std::cout << " SgDictionaryExp has size " << sizeOfActualPool << std::endl;
8803 0 : if ( 0 < sizeOfActualPool )
8804 : {
8805 0 : SgDictionaryExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8806 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8807 : {
8808 0 : new SgDictionaryExp ( SgDictionaryExpStorageArray[i] ) ;
8809 : }
8810 0 : delete [] SgDictionaryExpStorageArray;
8811 : }
8812 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDimensionObject ) ;
8813 0 : std::cout << " SgDimensionObject has size " << sizeOfActualPool << std::endl;
8814 0 : if ( 0 < sizeOfActualPool )
8815 : {
8816 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8817 : {
8818 0 : new SgDimensionObject ( SgDimensionObjectStorageArray[i] ) ;
8819 : }
8820 0 : delete [] SgDimensionObjectStorageArray;
8821 : }
8822 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDirectedGraphEdge ) ;
8823 0 : std::cout << " SgDirectedGraphEdge has size " << sizeOfActualPool << std::endl;
8824 0 : if ( 0 < sizeOfActualPool )
8825 : {
8826 0 : SgDirectedGraphEdgeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8827 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8828 : {
8829 0 : new SgDirectedGraphEdge ( SgDirectedGraphEdgeStorageArray[i] ) ;
8830 : }
8831 0 : delete [] SgDirectedGraphEdgeStorageArray;
8832 : }
8833 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDirectory ) ;
8834 0 : std::cout << " SgDirectory has size " << sizeOfActualPool << std::endl;
8835 0 : if ( 0 < sizeOfActualPool )
8836 : {
8837 0 : SgDirectoryStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8838 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8839 : {
8840 0 : new SgDirectory ( SgDirectoryStorageArray[i] ) ;
8841 : }
8842 0 : delete [] SgDirectoryStorageArray;
8843 : }
8844 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDirectoryList ) ;
8845 0 : std::cout << " SgDirectoryList has size " << sizeOfActualPool << std::endl;
8846 0 : if ( 0 < sizeOfActualPool )
8847 : {
8848 0 : SgDirectoryListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8849 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8850 : {
8851 0 : new SgDirectoryList ( SgDirectoryListStorageArray[i] ) ;
8852 : }
8853 0 : delete [] SgDirectoryListStorageArray;
8854 : }
8855 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDivAssignOp ) ;
8856 0 : std::cout << " SgDivAssignOp has size " << sizeOfActualPool << std::endl;
8857 0 : if ( 0 < sizeOfActualPool )
8858 : {
8859 0 : SgDivAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8860 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8861 : {
8862 0 : new SgDivAssignOp ( SgDivAssignOpStorageArray[i] ) ;
8863 : }
8864 0 : delete [] SgDivAssignOpStorageArray;
8865 : }
8866 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDivideOp ) ;
8867 0 : std::cout << " SgDivideOp has size " << sizeOfActualPool << std::endl;
8868 0 : if ( 0 < sizeOfActualPool )
8869 : {
8870 0 : SgDivideOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8871 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8872 : {
8873 0 : new SgDivideOp ( SgDivideOpStorageArray[i] ) ;
8874 : }
8875 0 : delete [] SgDivideOpStorageArray;
8876 : }
8877 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDoWhileStmt ) ;
8878 0 : std::cout << " SgDoWhileStmt has size " << sizeOfActualPool << std::endl;
8879 0 : if ( 0 < sizeOfActualPool )
8880 : {
8881 0 : SgDoWhileStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8882 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8883 : {
8884 0 : new SgDoWhileStmt ( SgDoWhileStmtStorageArray[i] ) ;
8885 : }
8886 0 : delete [] SgDoWhileStmtStorageArray;
8887 : }
8888 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDotExp ) ;
8889 0 : std::cout << " SgDotExp has size " << sizeOfActualPool << std::endl;
8890 0 : if ( 0 < sizeOfActualPool )
8891 : {
8892 0 : SgDotExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8893 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8894 : {
8895 0 : new SgDotExp ( SgDotExpStorageArray[i] ) ;
8896 : }
8897 0 : delete [] SgDotExpStorageArray;
8898 : }
8899 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDotStarOp ) ;
8900 0 : std::cout << " SgDotStarOp has size " << sizeOfActualPool << std::endl;
8901 0 : if ( 0 < sizeOfActualPool )
8902 : {
8903 0 : SgDotStarOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8904 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8905 : {
8906 0 : new SgDotStarOp ( SgDotStarOpStorageArray[i] ) ;
8907 : }
8908 0 : delete [] SgDotStarOpStorageArray;
8909 : }
8910 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgDoubleVal ) ;
8911 0 : std::cout << " SgDoubleVal has size " << sizeOfActualPool << std::endl;
8912 0 : if ( 0 < sizeOfActualPool )
8913 : {
8914 0 : SgDoubleValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8915 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8916 : {
8917 0 : new SgDoubleVal ( SgDoubleValStorageArray[i] ) ;
8918 : }
8919 0 : delete [] SgDoubleValStorageArray;
8920 : }
8921 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElaboratedTypeModifier ) ;
8922 0 : std::cout << " SgElaboratedTypeModifier has size " << sizeOfActualPool << std::endl;
8923 0 : if ( 0 < sizeOfActualPool )
8924 : {
8925 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8926 : {
8927 0 : new SgElaboratedTypeModifier ( SgElaboratedTypeModifierStorageArray[i] ) ;
8928 : }
8929 0 : delete [] SgElaboratedTypeModifierStorageArray;
8930 : }
8931 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseOp ) ;
8932 0 : std::cout << " SgElementwiseOp has size " << sizeOfActualPool << std::endl;
8933 0 : if ( 0 < sizeOfActualPool )
8934 : {
8935 0 : SgElementwiseOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8936 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8937 : {
8938 0 : new SgElementwiseOp ( SgElementwiseOpStorageArray[i] ) ;
8939 : }
8940 0 : delete [] SgElementwiseOpStorageArray;
8941 : }
8942 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseAddOp ) ;
8943 0 : std::cout << " SgElementwiseAddOp has size " << sizeOfActualPool << std::endl;
8944 0 : if ( 0 < sizeOfActualPool )
8945 : {
8946 0 : SgElementwiseAddOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8947 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8948 : {
8949 0 : new SgElementwiseAddOp ( SgElementwiseAddOpStorageArray[i] ) ;
8950 : }
8951 0 : delete [] SgElementwiseAddOpStorageArray;
8952 : }
8953 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseDivideOp ) ;
8954 0 : std::cout << " SgElementwiseDivideOp has size " << sizeOfActualPool << std::endl;
8955 0 : if ( 0 < sizeOfActualPool )
8956 : {
8957 0 : SgElementwiseDivideOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8958 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8959 : {
8960 0 : new SgElementwiseDivideOp ( SgElementwiseDivideOpStorageArray[i] ) ;
8961 : }
8962 0 : delete [] SgElementwiseDivideOpStorageArray;
8963 : }
8964 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseLeftDivideOp ) ;
8965 0 : std::cout << " SgElementwiseLeftDivideOp has size " << sizeOfActualPool << std::endl;
8966 0 : if ( 0 < sizeOfActualPool )
8967 : {
8968 0 : SgElementwiseLeftDivideOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8969 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8970 : {
8971 0 : new SgElementwiseLeftDivideOp ( SgElementwiseLeftDivideOpStorageArray[i] ) ;
8972 : }
8973 0 : delete [] SgElementwiseLeftDivideOpStorageArray;
8974 : }
8975 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseMultiplyOp ) ;
8976 0 : std::cout << " SgElementwiseMultiplyOp has size " << sizeOfActualPool << std::endl;
8977 0 : if ( 0 < sizeOfActualPool )
8978 : {
8979 0 : SgElementwiseMultiplyOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8980 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8981 : {
8982 0 : new SgElementwiseMultiplyOp ( SgElementwiseMultiplyOpStorageArray[i] ) ;
8983 : }
8984 0 : delete [] SgElementwiseMultiplyOpStorageArray;
8985 : }
8986 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwisePowerOp ) ;
8987 0 : std::cout << " SgElementwisePowerOp has size " << sizeOfActualPool << std::endl;
8988 0 : if ( 0 < sizeOfActualPool )
8989 : {
8990 0 : SgElementwisePowerOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
8991 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
8992 : {
8993 0 : new SgElementwisePowerOp ( SgElementwisePowerOpStorageArray[i] ) ;
8994 : }
8995 0 : delete [] SgElementwisePowerOpStorageArray;
8996 : }
8997 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElementwiseSubtractOp ) ;
8998 0 : std::cout << " SgElementwiseSubtractOp has size " << sizeOfActualPool << std::endl;
8999 0 : if ( 0 < sizeOfActualPool )
9000 : {
9001 0 : SgElementwiseSubtractOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9002 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9003 : {
9004 0 : new SgElementwiseSubtractOp ( SgElementwiseSubtractOpStorageArray[i] ) ;
9005 : }
9006 0 : delete [] SgElementwiseSubtractOpStorageArray;
9007 : }
9008 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElseDirectiveStatement ) ;
9009 0 : std::cout << " SgElseDirectiveStatement has size " << sizeOfActualPool << std::endl;
9010 0 : if ( 0 < sizeOfActualPool )
9011 : {
9012 0 : SgElseDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9013 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9014 : {
9015 0 : new SgElseDirectiveStatement ( SgElseDirectiveStatementStorageArray[i] ) ;
9016 : }
9017 0 : delete [] SgElseDirectiveStatementStorageArray;
9018 : }
9019 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElseWhereStatement ) ;
9020 0 : std::cout << " SgElseWhereStatement has size " << sizeOfActualPool << std::endl;
9021 0 : if ( 0 < sizeOfActualPool )
9022 : {
9023 0 : SgElseWhereStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9024 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9025 : {
9026 0 : new SgElseWhereStatement ( SgElseWhereStatementStorageArray[i] ) ;
9027 : }
9028 0 : delete [] SgElseWhereStatementStorageArray;
9029 : }
9030 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgElseifDirectiveStatement ) ;
9031 0 : std::cout << " SgElseifDirectiveStatement has size " << sizeOfActualPool << std::endl;
9032 0 : if ( 0 < sizeOfActualPool )
9033 : {
9034 0 : SgElseifDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9035 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9036 : {
9037 0 : new SgElseifDirectiveStatement ( SgElseifDirectiveStatementStorageArray[i] ) ;
9038 : }
9039 0 : delete [] SgElseifDirectiveStatementStorageArray;
9040 : }
9041 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEmptyDeclaration ) ;
9042 0 : std::cout << " SgEmptyDeclaration has size " << sizeOfActualPool << std::endl;
9043 0 : if ( 0 < sizeOfActualPool )
9044 : {
9045 0 : SgEmptyDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9046 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9047 : {
9048 0 : new SgEmptyDeclaration ( SgEmptyDeclarationStorageArray[i] ) ;
9049 : }
9050 0 : delete [] SgEmptyDeclarationStorageArray;
9051 : }
9052 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEmptyDirectiveStatement ) ;
9053 0 : std::cout << " SgEmptyDirectiveStatement has size " << sizeOfActualPool << std::endl;
9054 0 : if ( 0 < sizeOfActualPool )
9055 : {
9056 0 : SgEmptyDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9057 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9058 : {
9059 0 : new SgEmptyDirectiveStatement ( SgEmptyDirectiveStatementStorageArray[i] ) ;
9060 : }
9061 0 : delete [] SgEmptyDirectiveStatementStorageArray;
9062 : }
9063 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEndfileStatement ) ;
9064 0 : std::cout << " SgEndfileStatement has size " << sizeOfActualPool << std::endl;
9065 0 : if ( 0 < sizeOfActualPool )
9066 : {
9067 0 : SgEndfileStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9068 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9069 : {
9070 0 : new SgEndfileStatement ( SgEndfileStatementStorageArray[i] ) ;
9071 : }
9072 0 : delete [] SgEndfileStatementStorageArray;
9073 : }
9074 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEndifDirectiveStatement ) ;
9075 0 : std::cout << " SgEndifDirectiveStatement has size " << sizeOfActualPool << std::endl;
9076 0 : if ( 0 < sizeOfActualPool )
9077 : {
9078 0 : SgEndifDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9079 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9080 : {
9081 0 : new SgEndifDirectiveStatement ( SgEndifDirectiveStatementStorageArray[i] ) ;
9082 : }
9083 0 : delete [] SgEndifDirectiveStatementStorageArray;
9084 : }
9085 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEntryStatement ) ;
9086 0 : std::cout << " SgEntryStatement has size " << sizeOfActualPool << std::endl;
9087 0 : if ( 0 < sizeOfActualPool )
9088 : {
9089 0 : SgEntryStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9090 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9091 : {
9092 0 : new SgEntryStatement ( SgEntryStatementStorageArray[i] ) ;
9093 : }
9094 0 : delete [] SgEntryStatementStorageArray;
9095 : }
9096 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEnumDeclaration ) ;
9097 0 : std::cout << " SgEnumDeclaration has size " << sizeOfActualPool << std::endl;
9098 0 : if ( 0 < sizeOfActualPool )
9099 : {
9100 0 : SgEnumDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9101 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9102 : {
9103 0 : new SgEnumDeclaration ( SgEnumDeclarationStorageArray[i] ) ;
9104 : }
9105 0 : delete [] SgEnumDeclarationStorageArray;
9106 : }
9107 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEnumFieldSymbol ) ;
9108 0 : std::cout << " SgEnumFieldSymbol has size " << sizeOfActualPool << std::endl;
9109 0 : if ( 0 < sizeOfActualPool )
9110 : {
9111 0 : SgEnumFieldSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9112 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9113 : {
9114 0 : new SgEnumFieldSymbol ( SgEnumFieldSymbolStorageArray[i] ) ;
9115 : }
9116 0 : delete [] SgEnumFieldSymbolStorageArray;
9117 : }
9118 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEnumSymbol ) ;
9119 0 : std::cout << " SgEnumSymbol has size " << sizeOfActualPool << std::endl;
9120 0 : if ( 0 < sizeOfActualPool )
9121 : {
9122 0 : SgEnumSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9123 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9124 : {
9125 0 : new SgEnumSymbol ( SgEnumSymbolStorageArray[i] ) ;
9126 : }
9127 0 : delete [] SgEnumSymbolStorageArray;
9128 : }
9129 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEnumType ) ;
9130 0 : std::cout << " SgEnumType has size " << sizeOfActualPool << std::endl;
9131 0 : if ( 0 < sizeOfActualPool )
9132 : {
9133 0 : SgEnumTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9134 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9135 : {
9136 0 : new SgEnumType ( SgEnumTypeStorageArray[i] ) ;
9137 : }
9138 0 : delete [] SgEnumTypeStorageArray;
9139 : }
9140 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEnumVal ) ;
9141 0 : std::cout << " SgEnumVal has size " << sizeOfActualPool << std::endl;
9142 0 : if ( 0 < sizeOfActualPool )
9143 : {
9144 0 : SgEnumValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9145 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9146 : {
9147 0 : new SgEnumVal ( SgEnumValStorageArray[i] ) ;
9148 : }
9149 0 : delete [] SgEnumValStorageArray;
9150 : }
9151 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEqualityOp ) ;
9152 0 : std::cout << " SgEqualityOp has size " << sizeOfActualPool << std::endl;
9153 0 : if ( 0 < sizeOfActualPool )
9154 : {
9155 0 : SgEqualityOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9156 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9157 : {
9158 0 : new SgEqualityOp ( SgEqualityOpStorageArray[i] ) ;
9159 : }
9160 0 : delete [] SgEqualityOpStorageArray;
9161 : }
9162 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgEquivalenceStatement ) ;
9163 0 : std::cout << " SgEquivalenceStatement has size " << sizeOfActualPool << std::endl;
9164 0 : if ( 0 < sizeOfActualPool )
9165 : {
9166 0 : SgEquivalenceStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9167 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9168 : {
9169 0 : new SgEquivalenceStatement ( SgEquivalenceStatementStorageArray[i] ) ;
9170 : }
9171 0 : delete [] SgEquivalenceStatementStorageArray;
9172 : }
9173 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgErrorDirectiveStatement ) ;
9174 0 : std::cout << " SgErrorDirectiveStatement has size " << sizeOfActualPool << std::endl;
9175 0 : if ( 0 < sizeOfActualPool )
9176 : {
9177 0 : SgErrorDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9178 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9179 : {
9180 0 : new SgErrorDirectiveStatement ( SgErrorDirectiveStatementStorageArray[i] ) ;
9181 : }
9182 0 : delete [] SgErrorDirectiveStatementStorageArray;
9183 : }
9184 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExecStatement ) ;
9185 0 : std::cout << " SgExecStatement has size " << sizeOfActualPool << std::endl;
9186 0 : if ( 0 < sizeOfActualPool )
9187 : {
9188 0 : SgExecStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9189 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9190 : {
9191 0 : new SgExecStatement ( SgExecStatementStorageArray[i] ) ;
9192 : }
9193 0 : delete [] SgExecStatementStorageArray;
9194 : }
9195 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExponentiationOp ) ;
9196 0 : std::cout << " SgExponentiationOp has size " << sizeOfActualPool << std::endl;
9197 0 : if ( 0 < sizeOfActualPool )
9198 : {
9199 0 : SgExponentiationOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9200 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9201 : {
9202 0 : new SgExponentiationOp ( SgExponentiationOpStorageArray[i] ) ;
9203 : }
9204 0 : delete [] SgExponentiationOpStorageArray;
9205 : }
9206 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExponentiationAssignOp ) ;
9207 0 : std::cout << " SgExponentiationAssignOp has size " << sizeOfActualPool << std::endl;
9208 0 : if ( 0 < sizeOfActualPool )
9209 : {
9210 0 : SgExponentiationAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9211 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9212 : {
9213 0 : new SgExponentiationAssignOp ( SgExponentiationAssignOpStorageArray[i] ) ;
9214 : }
9215 0 : delete [] SgExponentiationAssignOpStorageArray;
9216 : }
9217 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExprListExp ) ;
9218 0 : std::cout << " SgExprListExp has size " << sizeOfActualPool << std::endl;
9219 0 : if ( 0 < sizeOfActualPool )
9220 : {
9221 0 : SgExprListExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9222 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9223 : {
9224 0 : new SgExprListExp ( SgExprListExpStorageArray[i] ) ;
9225 : }
9226 0 : delete [] SgExprListExpStorageArray;
9227 : }
9228 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExprStatement ) ;
9229 0 : std::cout << " SgExprStatement has size " << sizeOfActualPool << std::endl;
9230 0 : if ( 0 < sizeOfActualPool )
9231 : {
9232 0 : SgExprStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9233 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9234 : {
9235 0 : new SgExprStatement ( SgExprStatementStorageArray[i] ) ;
9236 : }
9237 0 : delete [] SgExprStatementStorageArray;
9238 : }
9239 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExpression ) ;
9240 0 : std::cout << " SgExpression has size " << sizeOfActualPool << std::endl;
9241 0 : if ( 0 < sizeOfActualPool )
9242 : {
9243 0 : SgExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9244 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9245 : {
9246 0 : new SgExpression ( SgExpressionStorageArray[i] ) ;
9247 : }
9248 0 : delete [] SgExpressionStorageArray;
9249 : }
9250 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgExpressionRoot ) ;
9251 0 : std::cout << " SgExpressionRoot has size " << sizeOfActualPool << std::endl;
9252 0 : if ( 0 < sizeOfActualPool )
9253 : {
9254 0 : SgExpressionRootStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9255 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9256 : {
9257 0 : new SgExpressionRoot ( SgExpressionRootStorageArray[i] ) ;
9258 : }
9259 0 : delete [] SgExpressionRootStorageArray;
9260 : }
9261 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFile ) ;
9262 0 : std::cout << " SgFile has size " << sizeOfActualPool << std::endl;
9263 0 : if ( 0 < sizeOfActualPool )
9264 : {
9265 0 : SgFileStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9266 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9267 : {
9268 0 : new SgFile ( SgFileStorageArray[i] ) ;
9269 : }
9270 0 : delete [] SgFileStorageArray;
9271 : }
9272 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFileList ) ;
9273 0 : std::cout << " SgFileList has size " << sizeOfActualPool << std::endl;
9274 0 : if ( 0 < sizeOfActualPool )
9275 : {
9276 0 : SgFileListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9277 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9278 : {
9279 0 : new SgFileList ( SgFileListStorageArray[i] ) ;
9280 : }
9281 0 : delete [] SgFileListStorageArray;
9282 : }
9283 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFloatVal ) ;
9284 0 : std::cout << " SgFloatVal has size " << sizeOfActualPool << std::endl;
9285 0 : if ( 0 < sizeOfActualPool )
9286 : {
9287 0 : SgFloatValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9288 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9289 : {
9290 0 : new SgFloatVal ( SgFloatValStorageArray[i] ) ;
9291 : }
9292 0 : delete [] SgFloatValStorageArray;
9293 : }
9294 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFloat128Val ) ;
9295 0 : std::cout << " SgFloat128Val has size " << sizeOfActualPool << std::endl;
9296 0 : if ( 0 < sizeOfActualPool )
9297 : {
9298 0 : SgFloat128ValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9299 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9300 : {
9301 0 : new SgFloat128Val ( SgFloat128ValStorageArray[i] ) ;
9302 : }
9303 0 : delete [] SgFloat128ValStorageArray;
9304 : }
9305 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFloat80Val ) ;
9306 0 : std::cout << " SgFloat80Val has size " << sizeOfActualPool << std::endl;
9307 0 : if ( 0 < sizeOfActualPool )
9308 : {
9309 0 : SgFloat80ValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9310 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9311 : {
9312 0 : new SgFloat80Val ( SgFloat80ValStorageArray[i] ) ;
9313 : }
9314 0 : delete [] SgFloat80ValStorageArray;
9315 : }
9316 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFoldExpression ) ;
9317 0 : std::cout << " SgFoldExpression has size " << sizeOfActualPool << std::endl;
9318 0 : if ( 0 < sizeOfActualPool )
9319 : {
9320 0 : SgFoldExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9321 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9322 : {
9323 0 : new SgFoldExpression ( SgFoldExpressionStorageArray[i] ) ;
9324 : }
9325 0 : delete [] SgFoldExpressionStorageArray;
9326 : }
9327 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFlushStatement ) ;
9328 0 : std::cout << " SgFlushStatement has size " << sizeOfActualPool << std::endl;
9329 0 : if ( 0 < sizeOfActualPool )
9330 : {
9331 0 : SgFlushStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9332 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9333 : {
9334 0 : new SgFlushStatement ( SgFlushStatementStorageArray[i] ) ;
9335 : }
9336 0 : delete [] SgFlushStatementStorageArray;
9337 : }
9338 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgForAllStatement ) ;
9339 0 : std::cout << " SgForAllStatement has size " << sizeOfActualPool << std::endl;
9340 0 : if ( 0 < sizeOfActualPool )
9341 : {
9342 0 : SgForAllStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9343 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9344 : {
9345 0 : new SgForAllStatement ( SgForAllStatementStorageArray[i] ) ;
9346 : }
9347 0 : delete [] SgForAllStatementStorageArray;
9348 : }
9349 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgForInitStatement ) ;
9350 0 : std::cout << " SgForInitStatement has size " << sizeOfActualPool << std::endl;
9351 0 : if ( 0 < sizeOfActualPool )
9352 : {
9353 0 : SgForInitStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9354 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9355 : {
9356 0 : new SgForInitStatement ( SgForInitStatementStorageArray[i] ) ;
9357 : }
9358 0 : delete [] SgForInitStatementStorageArray;
9359 : }
9360 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgForStatement ) ;
9361 0 : std::cout << " SgForStatement has size " << sizeOfActualPool << std::endl;
9362 0 : if ( 0 < sizeOfActualPool )
9363 : {
9364 0 : SgForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9365 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9366 : {
9367 0 : new SgForStatement ( SgForStatementStorageArray[i] ) ;
9368 : }
9369 0 : delete [] SgForStatementStorageArray;
9370 : }
9371 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFormatItem ) ;
9372 0 : std::cout << " SgFormatItem has size " << sizeOfActualPool << std::endl;
9373 0 : if ( 0 < sizeOfActualPool )
9374 : {
9375 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9376 : {
9377 0 : new SgFormatItem ( SgFormatItemStorageArray[i] ) ;
9378 : }
9379 0 : delete [] SgFormatItemStorageArray;
9380 : }
9381 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFormatItemList ) ;
9382 0 : std::cout << " SgFormatItemList has size " << sizeOfActualPool << std::endl;
9383 0 : if ( 0 < sizeOfActualPool )
9384 : {
9385 0 : SgFormatItemListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9386 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9387 : {
9388 0 : new SgFormatItemList ( SgFormatItemListStorageArray[i] ) ;
9389 : }
9390 0 : delete [] SgFormatItemListStorageArray;
9391 : }
9392 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFormatStatement ) ;
9393 0 : std::cout << " SgFormatStatement has size " << sizeOfActualPool << std::endl;
9394 0 : if ( 0 < sizeOfActualPool )
9395 : {
9396 0 : SgFormatStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9397 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9398 : {
9399 0 : new SgFormatStatement ( SgFormatStatementStorageArray[i] ) ;
9400 : }
9401 0 : delete [] SgFormatStatementStorageArray;
9402 : }
9403 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFortranDo ) ;
9404 0 : std::cout << " SgFortranDo has size " << sizeOfActualPool << std::endl;
9405 0 : if ( 0 < sizeOfActualPool )
9406 : {
9407 0 : SgFortranDoStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9408 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9409 : {
9410 0 : new SgFortranDo ( SgFortranDoStorageArray[i] ) ;
9411 : }
9412 0 : delete [] SgFortranDoStorageArray;
9413 : }
9414 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFortranIncludeLine ) ;
9415 0 : std::cout << " SgFortranIncludeLine has size " << sizeOfActualPool << std::endl;
9416 0 : if ( 0 < sizeOfActualPool )
9417 : {
9418 0 : SgFortranIncludeLineStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9419 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9420 : {
9421 0 : new SgFortranIncludeLine ( SgFortranIncludeLineStorageArray[i] ) ;
9422 : }
9423 0 : delete [] SgFortranIncludeLineStorageArray;
9424 : }
9425 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFortranNonblockedDo ) ;
9426 0 : std::cout << " SgFortranNonblockedDo has size " << sizeOfActualPool << std::endl;
9427 0 : if ( 0 < sizeOfActualPool )
9428 : {
9429 0 : SgFortranNonblockedDoStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9430 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9431 : {
9432 0 : new SgFortranNonblockedDo ( SgFortranNonblockedDoStorageArray[i] ) ;
9433 : }
9434 0 : delete [] SgFortranNonblockedDoStorageArray;
9435 : }
9436 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFuncDecl_attr ) ;
9437 0 : std::cout << " SgFuncDecl_attr has size " << sizeOfActualPool << std::endl;
9438 0 : if ( 0 < sizeOfActualPool )
9439 : {
9440 0 : SgFuncDecl_attrStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9441 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9442 : {
9443 0 : new SgFuncDecl_attr ( SgFuncDecl_attrStorageArray[i] ) ;
9444 : }
9445 0 : delete [] SgFuncDecl_attrStorageArray;
9446 : }
9447 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionCallExp ) ;
9448 0 : std::cout << " SgFunctionCallExp has size " << sizeOfActualPool << std::endl;
9449 0 : if ( 0 < sizeOfActualPool )
9450 : {
9451 0 : SgFunctionCallExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9452 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9453 : {
9454 0 : new SgFunctionCallExp ( SgFunctionCallExpStorageArray[i] ) ;
9455 : }
9456 0 : delete [] SgFunctionCallExpStorageArray;
9457 : }
9458 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionDeclaration ) ;
9459 0 : std::cout << " SgFunctionDeclaration has size " << sizeOfActualPool << std::endl;
9460 0 : if ( 0 < sizeOfActualPool )
9461 : {
9462 0 : SgFunctionDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9463 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9464 : {
9465 0 : new SgFunctionDeclaration ( SgFunctionDeclarationStorageArray[i] ) ;
9466 : }
9467 0 : delete [] SgFunctionDeclarationStorageArray;
9468 : }
9469 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionDefinition ) ;
9470 0 : std::cout << " SgFunctionDefinition has size " << sizeOfActualPool << std::endl;
9471 0 : if ( 0 < sizeOfActualPool )
9472 : {
9473 0 : SgFunctionDefinitionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9474 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9475 : {
9476 0 : new SgFunctionDefinition ( SgFunctionDefinitionStorageArray[i] ) ;
9477 : }
9478 0 : delete [] SgFunctionDefinitionStorageArray;
9479 : }
9480 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionParameterScope ) ;
9481 0 : std::cout << " SgFunctionParameterScope has size " << sizeOfActualPool << std::endl;
9482 0 : if ( 0 < sizeOfActualPool )
9483 : {
9484 0 : SgFunctionParameterScopeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9485 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9486 : {
9487 0 : new SgFunctionParameterScope ( SgFunctionParameterScopeStorageArray[i] ) ;
9488 : }
9489 0 : delete [] SgFunctionParameterScopeStorageArray;
9490 : }
9491 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionModifier ) ;
9492 0 : std::cout << " SgFunctionModifier has size " << sizeOfActualPool << std::endl;
9493 0 : if ( 0 < sizeOfActualPool )
9494 : {
9495 0 : SgFunctionModifierStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9496 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9497 : {
9498 0 : new SgFunctionModifier ( SgFunctionModifierStorageArray[i] ) ;
9499 : }
9500 0 : delete [] SgFunctionModifierStorageArray;
9501 : }
9502 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionParameterList ) ;
9503 0 : std::cout << " SgFunctionParameterList has size " << sizeOfActualPool << std::endl;
9504 0 : if ( 0 < sizeOfActualPool )
9505 : {
9506 0 : SgFunctionParameterListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9507 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9508 : {
9509 0 : new SgFunctionParameterList ( SgFunctionParameterListStorageArray[i] ) ;
9510 : }
9511 0 : delete [] SgFunctionParameterListStorageArray;
9512 : }
9513 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionParameterRefExp ) ;
9514 0 : std::cout << " SgFunctionParameterRefExp has size " << sizeOfActualPool << std::endl;
9515 0 : if ( 0 < sizeOfActualPool )
9516 : {
9517 0 : SgFunctionParameterRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9518 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9519 : {
9520 0 : new SgFunctionParameterRefExp ( SgFunctionParameterRefExpStorageArray[i] ) ;
9521 : }
9522 0 : delete [] SgFunctionParameterRefExpStorageArray;
9523 : }
9524 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionParameterTypeList ) ;
9525 0 : std::cout << " SgFunctionParameterTypeList has size " << sizeOfActualPool << std::endl;
9526 0 : if ( 0 < sizeOfActualPool )
9527 : {
9528 0 : SgFunctionParameterTypeListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9529 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9530 : {
9531 0 : new SgFunctionParameterTypeList ( SgFunctionParameterTypeListStorageArray[i] ) ;
9532 : }
9533 0 : delete [] SgFunctionParameterTypeListStorageArray;
9534 : }
9535 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionRefExp ) ;
9536 0 : std::cout << " SgFunctionRefExp has size " << sizeOfActualPool << std::endl;
9537 0 : if ( 0 < sizeOfActualPool )
9538 : {
9539 0 : SgFunctionRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9540 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9541 : {
9542 0 : new SgFunctionRefExp ( SgFunctionRefExpStorageArray[i] ) ;
9543 : }
9544 0 : delete [] SgFunctionRefExpStorageArray;
9545 : }
9546 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionSymbol ) ;
9547 0 : std::cout << " SgFunctionSymbol has size " << sizeOfActualPool << std::endl;
9548 0 : if ( 0 < sizeOfActualPool )
9549 : {
9550 0 : SgFunctionSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9551 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9552 : {
9553 0 : new SgFunctionSymbol ( SgFunctionSymbolStorageArray[i] ) ;
9554 : }
9555 0 : delete [] SgFunctionSymbolStorageArray;
9556 : }
9557 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionType ) ;
9558 0 : std::cout << " SgFunctionType has size " << sizeOfActualPool << std::endl;
9559 0 : if ( 0 < sizeOfActualPool )
9560 : {
9561 0 : SgFunctionTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9562 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9563 : {
9564 0 : new SgFunctionType ( SgFunctionTypeStorageArray[i] ) ;
9565 : }
9566 0 : delete [] SgFunctionTypeStorageArray;
9567 : }
9568 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionTypeSymbol ) ;
9569 0 : std::cout << " SgFunctionTypeSymbol has size " << sizeOfActualPool << std::endl;
9570 0 : if ( 0 < sizeOfActualPool )
9571 : {
9572 0 : SgFunctionTypeSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9573 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9574 : {
9575 0 : new SgFunctionTypeSymbol ( SgFunctionTypeSymbolStorageArray[i] ) ;
9576 : }
9577 0 : delete [] SgFunctionTypeSymbolStorageArray;
9578 : }
9579 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgFunctionTypeTable ) ;
9580 0 : std::cout << " SgFunctionTypeTable has size " << sizeOfActualPool << std::endl;
9581 0 : if ( 0 < sizeOfActualPool )
9582 : {
9583 0 : SgFunctionTypeTableStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9584 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9585 : {
9586 0 : new SgFunctionTypeTable ( SgFunctionTypeTableStorageArray[i] ) ;
9587 : }
9588 0 : delete [] SgFunctionTypeTableStorageArray;
9589 : }
9590 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeTable ) ;
9591 0 : std::cout << " SgTypeTable has size " << sizeOfActualPool << std::endl;
9592 0 : if ( 0 < sizeOfActualPool )
9593 : {
9594 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9595 : {
9596 0 : new SgTypeTable ( SgTypeTableStorageArray[i] ) ;
9597 : }
9598 0 : delete [] SgTypeTableStorageArray;
9599 : }
9600 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGlobal ) ;
9601 0 : std::cout << " SgGlobal has size " << sizeOfActualPool << std::endl;
9602 0 : if ( 0 < sizeOfActualPool )
9603 : {
9604 0 : SgGlobalStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9605 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9606 : {
9607 0 : new SgGlobal ( SgGlobalStorageArray[i] ) ;
9608 : }
9609 0 : delete [] SgGlobalStorageArray;
9610 : }
9611 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGotoStatement ) ;
9612 0 : std::cout << " SgGotoStatement has size " << sizeOfActualPool << std::endl;
9613 0 : if ( 0 < sizeOfActualPool )
9614 : {
9615 0 : SgGotoStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9616 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9617 : {
9618 0 : new SgGotoStatement ( SgGotoStatementStorageArray[i] ) ;
9619 : }
9620 0 : delete [] SgGotoStatementStorageArray;
9621 : }
9622 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGraph ) ;
9623 0 : std::cout << " SgGraph has size " << sizeOfActualPool << std::endl;
9624 0 : if ( 0 < sizeOfActualPool )
9625 : {
9626 0 : SgGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9627 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9628 : {
9629 0 : new SgGraph ( SgGraphStorageArray[i] ) ;
9630 : }
9631 0 : delete [] SgGraphStorageArray;
9632 : }
9633 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGraphEdge ) ;
9634 0 : std::cout << " SgGraphEdge has size " << sizeOfActualPool << std::endl;
9635 0 : if ( 0 < sizeOfActualPool )
9636 : {
9637 0 : SgGraphEdgeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9638 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9639 : {
9640 0 : new SgGraphEdge ( SgGraphEdgeStorageArray[i] ) ;
9641 : }
9642 0 : delete [] SgGraphEdgeStorageArray;
9643 : }
9644 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGraphEdgeList ) ;
9645 0 : std::cout << " SgGraphEdgeList has size " << sizeOfActualPool << std::endl;
9646 0 : if ( 0 < sizeOfActualPool )
9647 : {
9648 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9649 : {
9650 0 : new SgGraphEdgeList ( SgGraphEdgeListStorageArray[i] ) ;
9651 : }
9652 0 : delete [] SgGraphEdgeListStorageArray;
9653 : }
9654 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGraphNode ) ;
9655 0 : std::cout << " SgGraphNode has size " << sizeOfActualPool << std::endl;
9656 0 : if ( 0 < sizeOfActualPool )
9657 : {
9658 0 : SgGraphNodeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9659 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9660 : {
9661 0 : new SgGraphNode ( SgGraphNodeStorageArray[i] ) ;
9662 : }
9663 0 : delete [] SgGraphNodeStorageArray;
9664 : }
9665 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGraphNodeList ) ;
9666 0 : std::cout << " SgGraphNodeList has size " << sizeOfActualPool << std::endl;
9667 0 : if ( 0 < sizeOfActualPool )
9668 : {
9669 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9670 : {
9671 0 : new SgGraphNodeList ( SgGraphNodeListStorageArray[i] ) ;
9672 : }
9673 0 : delete [] SgGraphNodeListStorageArray;
9674 : }
9675 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGreaterOrEqualOp ) ;
9676 0 : std::cout << " SgGreaterOrEqualOp has size " << sizeOfActualPool << std::endl;
9677 0 : if ( 0 < sizeOfActualPool )
9678 : {
9679 0 : SgGreaterOrEqualOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9680 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9681 : {
9682 0 : new SgGreaterOrEqualOp ( SgGreaterOrEqualOpStorageArray[i] ) ;
9683 : }
9684 0 : delete [] SgGreaterOrEqualOpStorageArray;
9685 : }
9686 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgGreaterThanOp ) ;
9687 0 : std::cout << " SgGreaterThanOp has size " << sizeOfActualPool << std::endl;
9688 0 : if ( 0 < sizeOfActualPool )
9689 : {
9690 0 : SgGreaterThanOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9691 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9692 : {
9693 0 : new SgGreaterThanOp ( SgGreaterThanOpStorageArray[i] ) ;
9694 : }
9695 0 : delete [] SgGreaterThanOpStorageArray;
9696 : }
9697 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIOItemExpression ) ;
9698 0 : std::cout << " SgIOItemExpression has size " << sizeOfActualPool << std::endl;
9699 0 : if ( 0 < sizeOfActualPool )
9700 : {
9701 0 : SgIOItemExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9702 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9703 : {
9704 0 : new SgIOItemExpression ( SgIOItemExpressionStorageArray[i] ) ;
9705 : }
9706 0 : delete [] SgIOItemExpressionStorageArray;
9707 : }
9708 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIOStatement ) ;
9709 0 : std::cout << " SgIOStatement has size " << sizeOfActualPool << std::endl;
9710 0 : if ( 0 < sizeOfActualPool )
9711 : {
9712 0 : SgIOStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9713 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9714 : {
9715 0 : new SgIOStatement ( SgIOStatementStorageArray[i] ) ;
9716 : }
9717 0 : delete [] SgIOStatementStorageArray;
9718 : }
9719 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIdentDirectiveStatement ) ;
9720 0 : std::cout << " SgIdentDirectiveStatement has size " << sizeOfActualPool << std::endl;
9721 0 : if ( 0 < sizeOfActualPool )
9722 : {
9723 0 : SgIdentDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9724 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9725 : {
9726 0 : new SgIdentDirectiveStatement ( SgIdentDirectiveStatementStorageArray[i] ) ;
9727 : }
9728 0 : delete [] SgIdentDirectiveStatementStorageArray;
9729 : }
9730 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIfDirectiveStatement ) ;
9731 0 : std::cout << " SgIfDirectiveStatement has size " << sizeOfActualPool << std::endl;
9732 0 : if ( 0 < sizeOfActualPool )
9733 : {
9734 0 : SgIfDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9735 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9736 : {
9737 0 : new SgIfDirectiveStatement ( SgIfDirectiveStatementStorageArray[i] ) ;
9738 : }
9739 0 : delete [] SgIfDirectiveStatementStorageArray;
9740 : }
9741 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIfStmt ) ;
9742 0 : std::cout << " SgIfStmt has size " << sizeOfActualPool << std::endl;
9743 0 : if ( 0 < sizeOfActualPool )
9744 : {
9745 0 : SgIfStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9746 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9747 : {
9748 0 : new SgIfStmt ( SgIfStmtStorageArray[i] ) ;
9749 : }
9750 0 : delete [] SgIfStmtStorageArray;
9751 : }
9752 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIfdefDirectiveStatement ) ;
9753 0 : std::cout << " SgIfdefDirectiveStatement has size " << sizeOfActualPool << std::endl;
9754 0 : if ( 0 < sizeOfActualPool )
9755 : {
9756 0 : SgIfdefDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9757 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9758 : {
9759 0 : new SgIfdefDirectiveStatement ( SgIfdefDirectiveStatementStorageArray[i] ) ;
9760 : }
9761 0 : delete [] SgIfdefDirectiveStatementStorageArray;
9762 : }
9763 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIfndefDirectiveStatement ) ;
9764 0 : std::cout << " SgIfndefDirectiveStatement has size " << sizeOfActualPool << std::endl;
9765 0 : if ( 0 < sizeOfActualPool )
9766 : {
9767 0 : SgIfndefDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9768 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9769 : {
9770 0 : new SgIfndefDirectiveStatement ( SgIfndefDirectiveStatementStorageArray[i] ) ;
9771 : }
9772 0 : delete [] SgIfndefDirectiveStatementStorageArray;
9773 : }
9774 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgImageControlStatement ) ;
9775 0 : std::cout << " SgImageControlStatement has size " << sizeOfActualPool << std::endl;
9776 0 : if ( 0 < sizeOfActualPool )
9777 : {
9778 0 : SgImageControlStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9779 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9780 : {
9781 0 : new SgImageControlStatement ( SgImageControlStatementStorageArray[i] ) ;
9782 : }
9783 0 : delete [] SgImageControlStatementStorageArray;
9784 : }
9785 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgImagPartOp ) ;
9786 0 : std::cout << " SgImagPartOp has size " << sizeOfActualPool << std::endl;
9787 0 : if ( 0 < sizeOfActualPool )
9788 : {
9789 0 : SgImagPartOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9790 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9791 : {
9792 0 : new SgImagPartOp ( SgImagPartOpStorageArray[i] ) ;
9793 : }
9794 0 : delete [] SgImagPartOpStorageArray;
9795 : }
9796 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgImplicitStatement ) ;
9797 0 : std::cout << " SgImplicitStatement has size " << sizeOfActualPool << std::endl;
9798 0 : if ( 0 < sizeOfActualPool )
9799 : {
9800 0 : SgImplicitStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9801 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9802 : {
9803 0 : new SgImplicitStatement ( SgImplicitStatementStorageArray[i] ) ;
9804 : }
9805 0 : delete [] SgImplicitStatementStorageArray;
9806 : }
9807 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgImpliedDo ) ;
9808 0 : std::cout << " SgImpliedDo has size " << sizeOfActualPool << std::endl;
9809 0 : if ( 0 < sizeOfActualPool )
9810 : {
9811 0 : SgImpliedDoStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9812 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9813 : {
9814 0 : new SgImpliedDo ( SgImpliedDoStorageArray[i] ) ;
9815 : }
9816 0 : delete [] SgImpliedDoStorageArray;
9817 : }
9818 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgImportStatement ) ;
9819 0 : std::cout << " SgImportStatement has size " << sizeOfActualPool << std::endl;
9820 0 : if ( 0 < sizeOfActualPool )
9821 : {
9822 0 : SgImportStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9823 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9824 : {
9825 0 : new SgImportStatement ( SgImportStatementStorageArray[i] ) ;
9826 : }
9827 0 : delete [] SgImportStatementStorageArray;
9828 : }
9829 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIncidenceDirectedGraph ) ;
9830 0 : std::cout << " SgIncidenceDirectedGraph has size " << sizeOfActualPool << std::endl;
9831 0 : if ( 0 < sizeOfActualPool )
9832 : {
9833 0 : SgIncidenceDirectedGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9834 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9835 : {
9836 0 : new SgIncidenceDirectedGraph ( SgIncidenceDirectedGraphStorageArray[i] ) ;
9837 : }
9838 0 : delete [] SgIncidenceDirectedGraphStorageArray;
9839 : }
9840 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIncidenceUndirectedGraph ) ;
9841 0 : std::cout << " SgIncidenceUndirectedGraph has size " << sizeOfActualPool << std::endl;
9842 0 : if ( 0 < sizeOfActualPool )
9843 : {
9844 0 : SgIncidenceUndirectedGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9845 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9846 : {
9847 0 : new SgIncidenceUndirectedGraph ( SgIncidenceUndirectedGraphStorageArray[i] ) ;
9848 : }
9849 0 : delete [] SgIncidenceUndirectedGraphStorageArray;
9850 : }
9851 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIncludeDirectiveStatement ) ;
9852 0 : std::cout << " SgIncludeDirectiveStatement has size " << sizeOfActualPool << std::endl;
9853 0 : if ( 0 < sizeOfActualPool )
9854 : {
9855 0 : SgIncludeDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9856 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9857 : {
9858 0 : new SgIncludeDirectiveStatement ( SgIncludeDirectiveStatementStorageArray[i] ) ;
9859 : }
9860 0 : delete [] SgIncludeDirectiveStatementStorageArray;
9861 : }
9862 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIncludeFile ) ;
9863 0 : std::cout << " SgIncludeFile has size " << sizeOfActualPool << std::endl;
9864 0 : if ( 0 < sizeOfActualPool )
9865 : {
9866 0 : SgIncludeFileStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9867 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9868 : {
9869 0 : new SgIncludeFile ( SgIncludeFileStorageArray[i] ) ;
9870 : }
9871 0 : delete [] SgIncludeFileStorageArray;
9872 : }
9873 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIncludeNextDirectiveStatement ) ;
9874 0 : std::cout << " SgIncludeNextDirectiveStatement has size " << sizeOfActualPool << std::endl;
9875 0 : if ( 0 < sizeOfActualPool )
9876 : {
9877 0 : SgIncludeNextDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9878 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9879 : {
9880 0 : new SgIncludeNextDirectiveStatement ( SgIncludeNextDirectiveStatementStorageArray[i] ) ;
9881 : }
9882 0 : delete [] SgIncludeNextDirectiveStatementStorageArray;
9883 : }
9884 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInitializedName ) ;
9885 0 : std::cout << " SgInitializedName has size " << sizeOfActualPool << std::endl;
9886 0 : if ( 0 < sizeOfActualPool )
9887 : {
9888 0 : SgInitializedNameStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9889 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9890 : {
9891 0 : new SgInitializedName ( SgInitializedNameStorageArray[i] ) ;
9892 : }
9893 0 : delete [] SgInitializedNameStorageArray;
9894 : }
9895 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInitializer ) ;
9896 0 : std::cout << " SgInitializer has size " << sizeOfActualPool << std::endl;
9897 0 : if ( 0 < sizeOfActualPool )
9898 : {
9899 0 : SgInitializerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9900 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9901 : {
9902 0 : new SgInitializer ( SgInitializerStorageArray[i] ) ;
9903 : }
9904 0 : delete [] SgInitializerStorageArray;
9905 : }
9906 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInquireStatement ) ;
9907 0 : std::cout << " SgInquireStatement has size " << sizeOfActualPool << std::endl;
9908 0 : if ( 0 < sizeOfActualPool )
9909 : {
9910 0 : SgInquireStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9911 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9912 : {
9913 0 : new SgInquireStatement ( SgInquireStatementStorageArray[i] ) ;
9914 : }
9915 0 : delete [] SgInquireStatementStorageArray;
9916 : }
9917 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIntKeyedBidirectionalGraph ) ;
9918 0 : std::cout << " SgIntKeyedBidirectionalGraph has size " << sizeOfActualPool << std::endl;
9919 0 : if ( 0 < sizeOfActualPool )
9920 : {
9921 0 : SgIntKeyedBidirectionalGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9922 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9923 : {
9924 0 : new SgIntKeyedBidirectionalGraph ( SgIntKeyedBidirectionalGraphStorageArray[i] ) ;
9925 : }
9926 0 : delete [] SgIntKeyedBidirectionalGraphStorageArray;
9927 : }
9928 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIntVal ) ;
9929 0 : std::cout << " SgIntVal has size " << sizeOfActualPool << std::endl;
9930 0 : if ( 0 < sizeOfActualPool )
9931 : {
9932 0 : SgIntValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9933 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9934 : {
9935 0 : new SgIntVal ( SgIntValStorageArray[i] ) ;
9936 : }
9937 0 : delete [] SgIntValStorageArray;
9938 : }
9939 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIntegerDivideOp ) ;
9940 0 : std::cout << " SgIntegerDivideOp has size " << sizeOfActualPool << std::endl;
9941 0 : if ( 0 < sizeOfActualPool )
9942 : {
9943 0 : SgIntegerDivideOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9944 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9945 : {
9946 0 : new SgIntegerDivideOp ( SgIntegerDivideOpStorageArray[i] ) ;
9947 : }
9948 0 : delete [] SgIntegerDivideOpStorageArray;
9949 : }
9950 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIntegerDivideAssignOp ) ;
9951 0 : std::cout << " SgIntegerDivideAssignOp has size " << sizeOfActualPool << std::endl;
9952 0 : if ( 0 < sizeOfActualPool )
9953 : {
9954 0 : SgIntegerDivideAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9955 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9956 : {
9957 0 : new SgIntegerDivideAssignOp ( SgIntegerDivideAssignOpStorageArray[i] ) ;
9958 : }
9959 0 : delete [] SgIntegerDivideAssignOpStorageArray;
9960 : }
9961 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInterfaceBody ) ;
9962 0 : std::cout << " SgInterfaceBody has size " << sizeOfActualPool << std::endl;
9963 0 : if ( 0 < sizeOfActualPool )
9964 : {
9965 0 : SgInterfaceBodyStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9966 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9967 : {
9968 0 : new SgInterfaceBody ( SgInterfaceBodyStorageArray[i] ) ;
9969 : }
9970 0 : delete [] SgInterfaceBodyStorageArray;
9971 : }
9972 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgHeaderFileBody ) ;
9973 0 : std::cout << " SgHeaderFileBody has size " << sizeOfActualPool << std::endl;
9974 0 : if ( 0 < sizeOfActualPool )
9975 : {
9976 0 : SgHeaderFileBodyStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9977 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9978 : {
9979 0 : new SgHeaderFileBody ( SgHeaderFileBodyStorageArray[i] ) ;
9980 : }
9981 0 : delete [] SgHeaderFileBodyStorageArray;
9982 : }
9983 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgHeaderFileReport ) ;
9984 0 : std::cout << " SgHeaderFileReport has size " << sizeOfActualPool << std::endl;
9985 0 : if ( 0 < sizeOfActualPool )
9986 : {
9987 0 : SgHeaderFileReportStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9988 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
9989 : {
9990 0 : new SgHeaderFileReport ( SgHeaderFileReportStorageArray[i] ) ;
9991 : }
9992 0 : delete [] SgHeaderFileReportStorageArray;
9993 : }
9994 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInterfaceStatement ) ;
9995 0 : std::cout << " SgInterfaceStatement has size " << sizeOfActualPool << std::endl;
9996 0 : if ( 0 < sizeOfActualPool )
9997 : {
9998 0 : SgInterfaceStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
9999 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10000 : {
10001 0 : new SgInterfaceStatement ( SgInterfaceStatementStorageArray[i] ) ;
10002 : }
10003 0 : delete [] SgInterfaceStatementStorageArray;
10004 : }
10005 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgInterfaceSymbol ) ;
10006 0 : std::cout << " SgInterfaceSymbol has size " << sizeOfActualPool << std::endl;
10007 0 : if ( 0 < sizeOfActualPool )
10008 : {
10009 0 : SgInterfaceSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10010 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10011 : {
10012 0 : new SgInterfaceSymbol ( SgInterfaceSymbolStorageArray[i] ) ;
10013 : }
10014 0 : delete [] SgInterfaceSymbolStorageArray;
10015 : }
10016 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIntrinsicSymbol ) ;
10017 0 : std::cout << " SgIntrinsicSymbol has size " << sizeOfActualPool << std::endl;
10018 0 : if ( 0 < sizeOfActualPool )
10019 : {
10020 0 : SgIntrinsicSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10021 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10022 : {
10023 0 : new SgIntrinsicSymbol ( SgIntrinsicSymbolStorageArray[i] ) ;
10024 : }
10025 0 : delete [] SgIntrinsicSymbolStorageArray;
10026 : }
10027 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIsOp ) ;
10028 0 : std::cout << " SgIsOp has size " << sizeOfActualPool << std::endl;
10029 0 : if ( 0 < sizeOfActualPool )
10030 : {
10031 0 : SgIsOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10032 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10033 : {
10034 0 : new SgIsOp ( SgIsOpStorageArray[i] ) ;
10035 : }
10036 0 : delete [] SgIsOpStorageArray;
10037 : }
10038 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIsNotOp ) ;
10039 0 : std::cout << " SgIsNotOp has size " << sizeOfActualPool << std::endl;
10040 0 : if ( 0 < sizeOfActualPool )
10041 : {
10042 0 : SgIsNotOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10043 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10044 : {
10045 0 : new SgIsNotOp ( SgIsNotOpStorageArray[i] ) ;
10046 : }
10047 0 : delete [] SgIsNotOpStorageArray;
10048 : }
10049 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgIorAssignOp ) ;
10050 0 : std::cout << " SgIorAssignOp has size " << sizeOfActualPool << std::endl;
10051 0 : if ( 0 < sizeOfActualPool )
10052 : {
10053 0 : SgIorAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10054 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10055 : {
10056 0 : new SgIorAssignOp ( SgIorAssignOpStorageArray[i] ) ;
10057 : }
10058 0 : delete [] SgIorAssignOpStorageArray;
10059 : }
10060 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgKeyDatumPair ) ;
10061 0 : std::cout << " SgKeyDatumPair has size " << sizeOfActualPool << std::endl;
10062 0 : if ( 0 < sizeOfActualPool )
10063 : {
10064 0 : SgKeyDatumPairStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10065 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10066 : {
10067 0 : new SgKeyDatumPair ( SgKeyDatumPairStorageArray[i] ) ;
10068 : }
10069 0 : delete [] SgKeyDatumPairStorageArray;
10070 : }
10071 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCudaKernelExecConfig ) ;
10072 0 : std::cout << " SgCudaKernelExecConfig has size " << sizeOfActualPool << std::endl;
10073 0 : if ( 0 < sizeOfActualPool )
10074 : {
10075 0 : SgCudaKernelExecConfigStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10076 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10077 : {
10078 0 : new SgCudaKernelExecConfig ( SgCudaKernelExecConfigStorageArray[i] ) ;
10079 : }
10080 0 : delete [] SgCudaKernelExecConfigStorageArray;
10081 : }
10082 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCudaKernelCallExp ) ;
10083 0 : std::cout << " SgCudaKernelCallExp has size " << sizeOfActualPool << std::endl;
10084 0 : if ( 0 < sizeOfActualPool )
10085 : {
10086 0 : SgCudaKernelCallExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10087 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10088 : {
10089 0 : new SgCudaKernelCallExp ( SgCudaKernelCallExpStorageArray[i] ) ;
10090 : }
10091 0 : delete [] SgCudaKernelCallExpStorageArray;
10092 : }
10093 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLabelRefExp ) ;
10094 0 : std::cout << " SgLabelRefExp has size " << sizeOfActualPool << std::endl;
10095 0 : if ( 0 < sizeOfActualPool )
10096 : {
10097 0 : SgLabelRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10098 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10099 : {
10100 0 : new SgLabelRefExp ( SgLabelRefExpStorageArray[i] ) ;
10101 : }
10102 0 : delete [] SgLabelRefExpStorageArray;
10103 : }
10104 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLabelStatement ) ;
10105 0 : std::cout << " SgLabelStatement has size " << sizeOfActualPool << std::endl;
10106 0 : if ( 0 < sizeOfActualPool )
10107 : {
10108 0 : SgLabelStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10109 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10110 : {
10111 0 : new SgLabelStatement ( SgLabelStatementStorageArray[i] ) ;
10112 : }
10113 0 : delete [] SgLabelStatementStorageArray;
10114 : }
10115 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLabelSymbol ) ;
10116 0 : std::cout << " SgLabelSymbol has size " << sizeOfActualPool << std::endl;
10117 0 : if ( 0 < sizeOfActualPool )
10118 : {
10119 0 : SgLabelSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10120 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10121 : {
10122 0 : new SgLabelSymbol ( SgLabelSymbolStorageArray[i] ) ;
10123 : }
10124 0 : delete [] SgLabelSymbolStorageArray;
10125 : }
10126 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLambdaCapture ) ;
10127 0 : std::cout << " SgLambdaCapture has size " << sizeOfActualPool << std::endl;
10128 0 : if ( 0 < sizeOfActualPool )
10129 : {
10130 0 : SgLambdaCaptureStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10131 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10132 : {
10133 0 : new SgLambdaCapture ( SgLambdaCaptureStorageArray[i] ) ;
10134 : }
10135 0 : delete [] SgLambdaCaptureStorageArray;
10136 : }
10137 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLambdaCaptureList ) ;
10138 0 : std::cout << " SgLambdaCaptureList has size " << sizeOfActualPool << std::endl;
10139 0 : if ( 0 < sizeOfActualPool )
10140 : {
10141 0 : SgLambdaCaptureListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10142 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10143 : {
10144 0 : new SgLambdaCaptureList ( SgLambdaCaptureListStorageArray[i] ) ;
10145 : }
10146 0 : delete [] SgLambdaCaptureListStorageArray;
10147 : }
10148 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLambdaExp ) ;
10149 0 : std::cout << " SgLambdaExp has size " << sizeOfActualPool << std::endl;
10150 0 : if ( 0 < sizeOfActualPool )
10151 : {
10152 0 : SgLambdaExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10153 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10154 : {
10155 0 : new SgLambdaExp ( SgLambdaExpStorageArray[i] ) ;
10156 : }
10157 0 : delete [] SgLambdaExpStorageArray;
10158 : }
10159 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLambdaRefExp ) ;
10160 0 : std::cout << " SgLambdaRefExp has size " << sizeOfActualPool << std::endl;
10161 0 : if ( 0 < sizeOfActualPool )
10162 : {
10163 0 : SgLambdaRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10164 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10165 : {
10166 0 : new SgLambdaRefExp ( SgLambdaRefExpStorageArray[i] ) ;
10167 : }
10168 0 : delete [] SgLambdaRefExpStorageArray;
10169 : }
10170 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLeftDivideOp ) ;
10171 0 : std::cout << " SgLeftDivideOp has size " << sizeOfActualPool << std::endl;
10172 0 : if ( 0 < sizeOfActualPool )
10173 : {
10174 0 : SgLeftDivideOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10175 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10176 : {
10177 0 : new SgLeftDivideOp ( SgLeftDivideOpStorageArray[i] ) ;
10178 : }
10179 0 : delete [] SgLeftDivideOpStorageArray;
10180 : }
10181 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLessOrEqualOp ) ;
10182 0 : std::cout << " SgLessOrEqualOp has size " << sizeOfActualPool << std::endl;
10183 0 : if ( 0 < sizeOfActualPool )
10184 : {
10185 0 : SgLessOrEqualOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10186 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10187 : {
10188 0 : new SgLessOrEqualOp ( SgLessOrEqualOpStorageArray[i] ) ;
10189 : }
10190 0 : delete [] SgLessOrEqualOpStorageArray;
10191 : }
10192 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLessThanOp ) ;
10193 0 : std::cout << " SgLessThanOp has size " << sizeOfActualPool << std::endl;
10194 0 : if ( 0 < sizeOfActualPool )
10195 : {
10196 0 : SgLessThanOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10197 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10198 : {
10199 0 : new SgLessThanOp ( SgLessThanOpStorageArray[i] ) ;
10200 : }
10201 0 : delete [] SgLessThanOpStorageArray;
10202 : }
10203 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLineDirectiveStatement ) ;
10204 0 : std::cout << " SgLineDirectiveStatement has size " << sizeOfActualPool << std::endl;
10205 0 : if ( 0 < sizeOfActualPool )
10206 : {
10207 0 : SgLineDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10208 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10209 : {
10210 0 : new SgLineDirectiveStatement ( SgLineDirectiveStatementStorageArray[i] ) ;
10211 : }
10212 0 : delete [] SgLineDirectiveStatementStorageArray;
10213 : }
10214 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLinemarkerDirectiveStatement ) ;
10215 0 : std::cout << " SgLinemarkerDirectiveStatement has size " << sizeOfActualPool << std::endl;
10216 0 : if ( 0 < sizeOfActualPool )
10217 : {
10218 0 : SgLinemarkerDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10219 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10220 : {
10221 0 : new SgLinemarkerDirectiveStatement ( SgLinemarkerDirectiveStatementStorageArray[i] ) ;
10222 : }
10223 0 : delete [] SgLinemarkerDirectiveStatementStorageArray;
10224 : }
10225 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLinkageModifier ) ;
10226 0 : std::cout << " SgLinkageModifier has size " << sizeOfActualPool << std::endl;
10227 0 : if ( 0 < sizeOfActualPool )
10228 : {
10229 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10230 : {
10231 0 : new SgLinkageModifier ( SgLinkageModifierStorageArray[i] ) ;
10232 : }
10233 0 : delete [] SgLinkageModifierStorageArray;
10234 : }
10235 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgListComprehension ) ;
10236 0 : std::cout << " SgListComprehension has size " << sizeOfActualPool << std::endl;
10237 0 : if ( 0 < sizeOfActualPool )
10238 : {
10239 0 : SgListComprehensionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10240 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10241 : {
10242 0 : new SgListComprehension ( SgListComprehensionStorageArray[i] ) ;
10243 : }
10244 0 : delete [] SgListComprehensionStorageArray;
10245 : }
10246 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgListExp ) ;
10247 0 : std::cout << " SgListExp has size " << sizeOfActualPool << std::endl;
10248 0 : if ( 0 < sizeOfActualPool )
10249 : {
10250 0 : SgListExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10251 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10252 : {
10253 0 : new SgListExp ( SgListExpStorageArray[i] ) ;
10254 : }
10255 0 : delete [] SgListExpStorageArray;
10256 : }
10257 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLocatedNode ) ;
10258 0 : std::cout << " SgLocatedNode has size " << sizeOfActualPool << std::endl;
10259 0 : if ( 0 < sizeOfActualPool )
10260 : {
10261 0 : SgLocatedNodeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10262 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10263 : {
10264 0 : new SgLocatedNode ( SgLocatedNodeStorageArray[i] ) ;
10265 : }
10266 0 : delete [] SgLocatedNodeStorageArray;
10267 : }
10268 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLocatedNodeSupport ) ;
10269 0 : std::cout << " SgLocatedNodeSupport has size " << sizeOfActualPool << std::endl;
10270 0 : if ( 0 < sizeOfActualPool )
10271 : {
10272 0 : SgLocatedNodeSupportStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10273 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10274 : {
10275 0 : new SgLocatedNodeSupport ( SgLocatedNodeSupportStorageArray[i] ) ;
10276 : }
10277 0 : delete [] SgLocatedNodeSupportStorageArray;
10278 : }
10279 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLongDoubleVal ) ;
10280 0 : std::cout << " SgLongDoubleVal has size " << sizeOfActualPool << std::endl;
10281 0 : if ( 0 < sizeOfActualPool )
10282 : {
10283 0 : SgLongDoubleValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10284 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10285 : {
10286 0 : new SgLongDoubleVal ( SgLongDoubleValStorageArray[i] ) ;
10287 : }
10288 0 : delete [] SgLongDoubleValStorageArray;
10289 : }
10290 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLongIntVal ) ;
10291 0 : std::cout << " SgLongIntVal has size " << sizeOfActualPool << std::endl;
10292 0 : if ( 0 < sizeOfActualPool )
10293 : {
10294 0 : SgLongIntValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10295 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10296 : {
10297 0 : new SgLongIntVal ( SgLongIntValStorageArray[i] ) ;
10298 : }
10299 0 : delete [] SgLongIntValStorageArray;
10300 : }
10301 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLongLongIntVal ) ;
10302 0 : std::cout << " SgLongLongIntVal has size " << sizeOfActualPool << std::endl;
10303 0 : if ( 0 < sizeOfActualPool )
10304 : {
10305 0 : SgLongLongIntValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10306 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10307 : {
10308 0 : new SgLongLongIntVal ( SgLongLongIntValStorageArray[i] ) ;
10309 : }
10310 0 : delete [] SgLongLongIntValStorageArray;
10311 : }
10312 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLshiftAssignOp ) ;
10313 0 : std::cout << " SgLshiftAssignOp has size " << sizeOfActualPool << std::endl;
10314 0 : if ( 0 < sizeOfActualPool )
10315 : {
10316 0 : SgLshiftAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10317 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10318 : {
10319 0 : new SgLshiftAssignOp ( SgLshiftAssignOpStorageArray[i] ) ;
10320 : }
10321 0 : delete [] SgLshiftAssignOpStorageArray;
10322 : }
10323 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLshiftOp ) ;
10324 0 : std::cout << " SgLshiftOp has size " << sizeOfActualPool << std::endl;
10325 0 : if ( 0 < sizeOfActualPool )
10326 : {
10327 0 : SgLshiftOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10328 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10329 : {
10330 0 : new SgLshiftOp ( SgLshiftOpStorageArray[i] ) ;
10331 : }
10332 0 : delete [] SgLshiftOpStorageArray;
10333 : }
10334 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMagicColonExp ) ;
10335 0 : std::cout << " SgMagicColonExp has size " << sizeOfActualPool << std::endl;
10336 0 : if ( 0 < sizeOfActualPool )
10337 : {
10338 0 : SgMagicColonExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10339 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10340 : {
10341 0 : new SgMagicColonExp ( SgMagicColonExpStorageArray[i] ) ;
10342 : }
10343 0 : delete [] SgMagicColonExpStorageArray;
10344 : }
10345 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMatrixExp ) ;
10346 0 : std::cout << " SgMatrixExp has size " << sizeOfActualPool << std::endl;
10347 0 : if ( 0 < sizeOfActualPool )
10348 : {
10349 0 : SgMatrixExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10350 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10351 : {
10352 0 : new SgMatrixExp ( SgMatrixExpStorageArray[i] ) ;
10353 : }
10354 0 : delete [] SgMatrixExpStorageArray;
10355 : }
10356 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMatrixTransposeOp ) ;
10357 0 : std::cout << " SgMatrixTransposeOp has size " << sizeOfActualPool << std::endl;
10358 0 : if ( 0 < sizeOfActualPool )
10359 : {
10360 0 : SgMatrixTransposeOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10361 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10362 : {
10363 0 : new SgMatrixTransposeOp ( SgMatrixTransposeOpStorageArray[i] ) ;
10364 : }
10365 0 : delete [] SgMatrixTransposeOpStorageArray;
10366 : }
10367 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMemberFunctionDeclaration ) ;
10368 0 : std::cout << " SgMemberFunctionDeclaration has size " << sizeOfActualPool << std::endl;
10369 0 : if ( 0 < sizeOfActualPool )
10370 : {
10371 0 : SgMemberFunctionDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10372 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10373 : {
10374 0 : new SgMemberFunctionDeclaration ( SgMemberFunctionDeclarationStorageArray[i] ) ;
10375 : }
10376 0 : delete [] SgMemberFunctionDeclarationStorageArray;
10377 : }
10378 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMemberFunctionRefExp ) ;
10379 0 : std::cout << " SgMemberFunctionRefExp has size " << sizeOfActualPool << std::endl;
10380 0 : if ( 0 < sizeOfActualPool )
10381 : {
10382 0 : SgMemberFunctionRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10383 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10384 : {
10385 0 : new SgMemberFunctionRefExp ( SgMemberFunctionRefExpStorageArray[i] ) ;
10386 : }
10387 0 : delete [] SgMemberFunctionRefExpStorageArray;
10388 : }
10389 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMemberFunctionSymbol ) ;
10390 0 : std::cout << " SgMemberFunctionSymbol has size " << sizeOfActualPool << std::endl;
10391 0 : if ( 0 < sizeOfActualPool )
10392 : {
10393 0 : SgMemberFunctionSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10394 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10395 : {
10396 0 : new SgMemberFunctionSymbol ( SgMemberFunctionSymbolStorageArray[i] ) ;
10397 : }
10398 0 : delete [] SgMemberFunctionSymbolStorageArray;
10399 : }
10400 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMemberFunctionType ) ;
10401 0 : std::cout << " SgMemberFunctionType has size " << sizeOfActualPool << std::endl;
10402 0 : if ( 0 < sizeOfActualPool )
10403 : {
10404 0 : SgMemberFunctionTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10405 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10406 : {
10407 0 : new SgMemberFunctionType ( SgMemberFunctionTypeStorageArray[i] ) ;
10408 : }
10409 0 : delete [] SgMemberFunctionTypeStorageArray;
10410 : }
10411 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMembershipOp ) ;
10412 0 : std::cout << " SgMembershipOp has size " << sizeOfActualPool << std::endl;
10413 0 : if ( 0 < sizeOfActualPool )
10414 : {
10415 0 : SgMembershipOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10416 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10417 : {
10418 0 : new SgMembershipOp ( SgMembershipOpStorageArray[i] ) ;
10419 : }
10420 0 : delete [] SgMembershipOpStorageArray;
10421 : }
10422 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMicrosoftAttributeDeclaration ) ;
10423 0 : std::cout << " SgMicrosoftAttributeDeclaration has size " << sizeOfActualPool << std::endl;
10424 0 : if ( 0 < sizeOfActualPool )
10425 : {
10426 0 : SgMicrosoftAttributeDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10427 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10428 : {
10429 0 : new SgMicrosoftAttributeDeclaration ( SgMicrosoftAttributeDeclarationStorageArray[i] ) ;
10430 : }
10431 0 : delete [] SgMicrosoftAttributeDeclarationStorageArray;
10432 : }
10433 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMinusAssignOp ) ;
10434 0 : std::cout << " SgMinusAssignOp has size " << sizeOfActualPool << std::endl;
10435 0 : if ( 0 < sizeOfActualPool )
10436 : {
10437 0 : SgMinusAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10438 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10439 : {
10440 0 : new SgMinusAssignOp ( SgMinusAssignOpStorageArray[i] ) ;
10441 : }
10442 0 : delete [] SgMinusAssignOpStorageArray;
10443 : }
10444 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMinusMinusOp ) ;
10445 0 : std::cout << " SgMinusMinusOp has size " << sizeOfActualPool << std::endl;
10446 0 : if ( 0 < sizeOfActualPool )
10447 : {
10448 0 : SgMinusMinusOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10449 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10450 : {
10451 0 : new SgMinusMinusOp ( SgMinusMinusOpStorageArray[i] ) ;
10452 : }
10453 0 : delete [] SgMinusMinusOpStorageArray;
10454 : }
10455 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMinusOp ) ;
10456 0 : std::cout << " SgMinusOp has size " << sizeOfActualPool << std::endl;
10457 0 : if ( 0 < sizeOfActualPool )
10458 : {
10459 0 : SgMinusOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10460 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10461 : {
10462 0 : new SgMinusOp ( SgMinusOpStorageArray[i] ) ;
10463 : }
10464 0 : delete [] SgMinusOpStorageArray;
10465 : }
10466 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModAssignOp ) ;
10467 0 : std::cout << " SgModAssignOp has size " << sizeOfActualPool << std::endl;
10468 0 : if ( 0 < sizeOfActualPool )
10469 : {
10470 0 : SgModAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10471 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10472 : {
10473 0 : new SgModAssignOp ( SgModAssignOpStorageArray[i] ) ;
10474 : }
10475 0 : delete [] SgModAssignOpStorageArray;
10476 : }
10477 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModOp ) ;
10478 0 : std::cout << " SgModOp has size " << sizeOfActualPool << std::endl;
10479 0 : if ( 0 < sizeOfActualPool )
10480 : {
10481 0 : SgModOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10482 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10483 : {
10484 0 : new SgModOp ( SgModOpStorageArray[i] ) ;
10485 : }
10486 0 : delete [] SgModOpStorageArray;
10487 : }
10488 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModifier ) ;
10489 0 : std::cout << " SgModifier has size " << sizeOfActualPool << std::endl;
10490 0 : if ( 0 < sizeOfActualPool )
10491 : {
10492 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10493 : {
10494 0 : new SgModifier ( SgModifierStorageArray[i] ) ;
10495 : }
10496 0 : delete [] SgModifierStorageArray;
10497 : }
10498 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModifierNodes ) ;
10499 0 : std::cout << " SgModifierNodes has size " << sizeOfActualPool << std::endl;
10500 0 : if ( 0 < sizeOfActualPool )
10501 : {
10502 0 : SgModifierNodesStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10503 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10504 : {
10505 0 : new SgModifierNodes ( SgModifierNodesStorageArray[i] ) ;
10506 : }
10507 0 : delete [] SgModifierNodesStorageArray;
10508 : }
10509 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModifierType ) ;
10510 0 : std::cout << " SgModifierType has size " << sizeOfActualPool << std::endl;
10511 0 : if ( 0 < sizeOfActualPool )
10512 : {
10513 0 : SgModifierTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10514 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10515 : {
10516 0 : new SgModifierType ( SgModifierTypeStorageArray[i] ) ;
10517 : }
10518 0 : delete [] SgModifierTypeStorageArray;
10519 : }
10520 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModuleStatement ) ;
10521 0 : std::cout << " SgModuleStatement has size " << sizeOfActualPool << std::endl;
10522 0 : if ( 0 < sizeOfActualPool )
10523 : {
10524 0 : SgModuleStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10525 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10526 : {
10527 0 : new SgModuleStatement ( SgModuleStatementStorageArray[i] ) ;
10528 : }
10529 0 : delete [] SgModuleStatementStorageArray;
10530 : }
10531 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgModuleSymbol ) ;
10532 0 : std::cout << " SgModuleSymbol has size " << sizeOfActualPool << std::endl;
10533 0 : if ( 0 < sizeOfActualPool )
10534 : {
10535 0 : SgModuleSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10536 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10537 : {
10538 0 : new SgModuleSymbol ( SgModuleSymbolStorageArray[i] ) ;
10539 : }
10540 0 : delete [] SgModuleSymbolStorageArray;
10541 : }
10542 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMultAssignOp ) ;
10543 0 : std::cout << " SgMultAssignOp has size " << sizeOfActualPool << std::endl;
10544 0 : if ( 0 < sizeOfActualPool )
10545 : {
10546 0 : SgMultAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10547 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10548 : {
10549 0 : new SgMultAssignOp ( SgMultAssignOpStorageArray[i] ) ;
10550 : }
10551 0 : delete [] SgMultAssignOpStorageArray;
10552 : }
10553 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgMultiplyOp ) ;
10554 0 : std::cout << " SgMultiplyOp has size " << sizeOfActualPool << std::endl;
10555 0 : if ( 0 < sizeOfActualPool )
10556 : {
10557 0 : SgMultiplyOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10558 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10559 : {
10560 0 : new SgMultiplyOp ( SgMultiplyOpStorageArray[i] ) ;
10561 : }
10562 0 : delete [] SgMultiplyOpStorageArray;
10563 : }
10564 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgName ) ;
10565 0 : std::cout << " SgName has size " << sizeOfActualPool << std::endl;
10566 0 : if ( 0 < sizeOfActualPool )
10567 : {
10568 0 : SgNameStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10569 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10570 : {
10571 0 : new SgName ( SgNameStorageArray[i] ) ;
10572 : }
10573 0 : delete [] SgNameStorageArray;
10574 : }
10575 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNameGroup ) ;
10576 0 : std::cout << " SgNameGroup has size " << sizeOfActualPool << std::endl;
10577 0 : if ( 0 < sizeOfActualPool )
10578 : {
10579 0 : SgNameGroupStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10580 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10581 : {
10582 0 : new SgNameGroup ( SgNameGroupStorageArray[i] ) ;
10583 : }
10584 0 : delete [] SgNameGroupStorageArray;
10585 : }
10586 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamedType ) ;
10587 0 : std::cout << " SgNamedType has size " << sizeOfActualPool << std::endl;
10588 0 : if ( 0 < sizeOfActualPool )
10589 : {
10590 0 : SgNamedTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10591 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10592 : {
10593 0 : new SgNamedType ( SgNamedTypeStorageArray[i] ) ;
10594 : }
10595 0 : delete [] SgNamedTypeStorageArray;
10596 : }
10597 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamelistStatement ) ;
10598 0 : std::cout << " SgNamelistStatement has size " << sizeOfActualPool << std::endl;
10599 0 : if ( 0 < sizeOfActualPool )
10600 : {
10601 0 : SgNamelistStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10602 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10603 : {
10604 0 : new SgNamelistStatement ( SgNamelistStatementStorageArray[i] ) ;
10605 : }
10606 0 : delete [] SgNamelistStatementStorageArray;
10607 : }
10608 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamespaceAliasDeclarationStatement ) ;
10609 0 : std::cout << " SgNamespaceAliasDeclarationStatement has size " << sizeOfActualPool << std::endl;
10610 0 : if ( 0 < sizeOfActualPool )
10611 : {
10612 0 : SgNamespaceAliasDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10613 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10614 : {
10615 0 : new SgNamespaceAliasDeclarationStatement ( SgNamespaceAliasDeclarationStatementStorageArray[i] ) ;
10616 : }
10617 0 : delete [] SgNamespaceAliasDeclarationStatementStorageArray;
10618 : }
10619 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamespaceDeclarationStatement ) ;
10620 0 : std::cout << " SgNamespaceDeclarationStatement has size " << sizeOfActualPool << std::endl;
10621 0 : if ( 0 < sizeOfActualPool )
10622 : {
10623 0 : SgNamespaceDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10624 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10625 : {
10626 0 : new SgNamespaceDeclarationStatement ( SgNamespaceDeclarationStatementStorageArray[i] ) ;
10627 : }
10628 0 : delete [] SgNamespaceDeclarationStatementStorageArray;
10629 : }
10630 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamespaceDefinitionStatement ) ;
10631 0 : std::cout << " SgNamespaceDefinitionStatement has size " << sizeOfActualPool << std::endl;
10632 0 : if ( 0 < sizeOfActualPool )
10633 : {
10634 0 : SgNamespaceDefinitionStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10635 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10636 : {
10637 0 : new SgNamespaceDefinitionStatement ( SgNamespaceDefinitionStatementStorageArray[i] ) ;
10638 : }
10639 0 : delete [] SgNamespaceDefinitionStatementStorageArray;
10640 : }
10641 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNamespaceSymbol ) ;
10642 0 : std::cout << " SgNamespaceSymbol has size " << sizeOfActualPool << std::endl;
10643 0 : if ( 0 < sizeOfActualPool )
10644 : {
10645 0 : SgNamespaceSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10646 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10647 : {
10648 0 : new SgNamespaceSymbol ( SgNamespaceSymbolStorageArray[i] ) ;
10649 : }
10650 0 : delete [] SgNamespaceSymbolStorageArray;
10651 : }
10652 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNaryOp ) ;
10653 0 : std::cout << " SgNaryOp has size " << sizeOfActualPool << std::endl;
10654 0 : if ( 0 < sizeOfActualPool )
10655 : {
10656 0 : SgNaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10657 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10658 : {
10659 0 : new SgNaryOp ( SgNaryOpStorageArray[i] ) ;
10660 : }
10661 0 : delete [] SgNaryOpStorageArray;
10662 : }
10663 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNaryBooleanOp ) ;
10664 0 : std::cout << " SgNaryBooleanOp has size " << sizeOfActualPool << std::endl;
10665 0 : if ( 0 < sizeOfActualPool )
10666 : {
10667 0 : SgNaryBooleanOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10668 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10669 : {
10670 0 : new SgNaryBooleanOp ( SgNaryBooleanOpStorageArray[i] ) ;
10671 : }
10672 0 : delete [] SgNaryBooleanOpStorageArray;
10673 : }
10674 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNaryComparisonOp ) ;
10675 0 : std::cout << " SgNaryComparisonOp has size " << sizeOfActualPool << std::endl;
10676 0 : if ( 0 < sizeOfActualPool )
10677 : {
10678 0 : SgNaryComparisonOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10679 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10680 : {
10681 0 : new SgNaryComparisonOp ( SgNaryComparisonOpStorageArray[i] ) ;
10682 : }
10683 0 : delete [] SgNaryComparisonOpStorageArray;
10684 : }
10685 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNewExp ) ;
10686 0 : std::cout << " SgNewExp has size " << sizeOfActualPool << std::endl;
10687 0 : if ( 0 < sizeOfActualPool )
10688 : {
10689 0 : SgNewExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10690 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10691 : {
10692 0 : new SgNewExp ( SgNewExpStorageArray[i] ) ;
10693 : }
10694 0 : delete [] SgNewExpStorageArray;
10695 : }
10696 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNode ) ;
10697 0 : std::cout << " SgNode has size " << sizeOfActualPool << std::endl;
10698 0 : if ( 0 < sizeOfActualPool )
10699 : {
10700 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10701 : {
10702 0 : new SgNode ( SgNodeStorageArray[i] ) ;
10703 : }
10704 0 : delete [] SgNodeStorageArray;
10705 : }
10706 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNoexceptOp ) ;
10707 0 : std::cout << " SgNoexceptOp has size " << sizeOfActualPool << std::endl;
10708 0 : if ( 0 < sizeOfActualPool )
10709 : {
10710 0 : SgNoexceptOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10711 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10712 : {
10713 0 : new SgNoexceptOp ( SgNoexceptOpStorageArray[i] ) ;
10714 : }
10715 0 : delete [] SgNoexceptOpStorageArray;
10716 : }
10717 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNotEqualOp ) ;
10718 0 : std::cout << " SgNotEqualOp has size " << sizeOfActualPool << std::endl;
10719 0 : if ( 0 < sizeOfActualPool )
10720 : {
10721 0 : SgNotEqualOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10722 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10723 : {
10724 0 : new SgNotEqualOp ( SgNotEqualOpStorageArray[i] ) ;
10725 : }
10726 0 : delete [] SgNotEqualOpStorageArray;
10727 : }
10728 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNotOp ) ;
10729 0 : std::cout << " SgNotOp has size " << sizeOfActualPool << std::endl;
10730 0 : if ( 0 < sizeOfActualPool )
10731 : {
10732 0 : SgNotOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10733 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10734 : {
10735 0 : new SgNotOp ( SgNotOpStorageArray[i] ) ;
10736 : }
10737 0 : delete [] SgNotOpStorageArray;
10738 : }
10739 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonMembershipOp ) ;
10740 0 : std::cout << " SgNonMembershipOp has size " << sizeOfActualPool << std::endl;
10741 0 : if ( 0 < sizeOfActualPool )
10742 : {
10743 0 : SgNonMembershipOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10744 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10745 : {
10746 0 : new SgNonMembershipOp ( SgNonMembershipOpStorageArray[i] ) ;
10747 : }
10748 0 : delete [] SgNonMembershipOpStorageArray;
10749 : }
10750 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonrealDecl ) ;
10751 0 : std::cout << " SgNonrealDecl has size " << sizeOfActualPool << std::endl;
10752 0 : if ( 0 < sizeOfActualPool )
10753 : {
10754 0 : SgNonrealDeclStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10755 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10756 : {
10757 0 : new SgNonrealDecl ( SgNonrealDeclStorageArray[i] ) ;
10758 : }
10759 0 : delete [] SgNonrealDeclStorageArray;
10760 : }
10761 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonrealRefExp ) ;
10762 0 : std::cout << " SgNonrealRefExp has size " << sizeOfActualPool << std::endl;
10763 0 : if ( 0 < sizeOfActualPool )
10764 : {
10765 0 : SgNonrealRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10766 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10767 : {
10768 0 : new SgNonrealRefExp ( SgNonrealRefExpStorageArray[i] ) ;
10769 : }
10770 0 : delete [] SgNonrealRefExpStorageArray;
10771 : }
10772 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonrealSymbol ) ;
10773 0 : std::cout << " SgNonrealSymbol has size " << sizeOfActualPool << std::endl;
10774 0 : if ( 0 < sizeOfActualPool )
10775 : {
10776 0 : SgNonrealSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10777 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10778 : {
10779 0 : new SgNonrealSymbol ( SgNonrealSymbolStorageArray[i] ) ;
10780 : }
10781 0 : delete [] SgNonrealSymbolStorageArray;
10782 : }
10783 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonrealType ) ;
10784 0 : std::cout << " SgNonrealType has size " << sizeOfActualPool << std::endl;
10785 0 : if ( 0 < sizeOfActualPool )
10786 : {
10787 0 : SgNonrealTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10788 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10789 : {
10790 0 : new SgNonrealType ( SgNonrealTypeStorageArray[i] ) ;
10791 : }
10792 0 : delete [] SgNonrealTypeStorageArray;
10793 : }
10794 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNonrealBaseClass ) ;
10795 0 : std::cout << " SgNonrealBaseClass has size " << sizeOfActualPool << std::endl;
10796 0 : if ( 0 < sizeOfActualPool )
10797 : {
10798 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10799 : {
10800 0 : new SgNonrealBaseClass ( SgNonrealBaseClassStorageArray[i] ) ;
10801 : }
10802 0 : delete [] SgNonrealBaseClassStorageArray;
10803 : }
10804 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNullExpression ) ;
10805 0 : std::cout << " SgNullExpression has size " << sizeOfActualPool << std::endl;
10806 0 : if ( 0 < sizeOfActualPool )
10807 : {
10808 0 : SgNullExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10809 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10810 : {
10811 0 : new SgNullExpression ( SgNullExpressionStorageArray[i] ) ;
10812 : }
10813 0 : delete [] SgNullExpressionStorageArray;
10814 : }
10815 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNullptrValExp ) ;
10816 0 : std::cout << " SgNullptrValExp has size " << sizeOfActualPool << std::endl;
10817 0 : if ( 0 < sizeOfActualPool )
10818 : {
10819 0 : SgNullptrValExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10820 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10821 : {
10822 0 : new SgNullptrValExp ( SgNullptrValExpStorageArray[i] ) ;
10823 : }
10824 0 : delete [] SgNullptrValExpStorageArray;
10825 : }
10826 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNullStatement ) ;
10827 0 : std::cout << " SgNullStatement has size " << sizeOfActualPool << std::endl;
10828 0 : if ( 0 < sizeOfActualPool )
10829 : {
10830 0 : SgNullStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10831 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10832 : {
10833 0 : new SgNullStatement ( SgNullStatementStorageArray[i] ) ;
10834 : }
10835 0 : delete [] SgNullStatementStorageArray;
10836 : }
10837 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgNullifyStatement ) ;
10838 0 : std::cout << " SgNullifyStatement has size " << sizeOfActualPool << std::endl;
10839 0 : if ( 0 < sizeOfActualPool )
10840 : {
10841 0 : SgNullifyStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10842 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10843 : {
10844 0 : new SgNullifyStatement ( SgNullifyStatementStorageArray[i] ) ;
10845 : }
10846 0 : delete [] SgNullifyStatementStorageArray;
10847 : }
10848 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAtomicStatement ) ;
10849 0 : std::cout << " SgOmpAtomicStatement has size " << sizeOfActualPool << std::endl;
10850 0 : if ( 0 < sizeOfActualPool )
10851 : {
10852 0 : SgOmpAtomicStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10853 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10854 : {
10855 0 : new SgOmpAtomicStatement ( SgOmpAtomicStatementStorageArray[i] ) ;
10856 : }
10857 0 : delete [] SgOmpAtomicStatementStorageArray;
10858 : }
10859 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpBarrierStatement ) ;
10860 0 : std::cout << " SgOmpBarrierStatement has size " << sizeOfActualPool << std::endl;
10861 0 : if ( 0 < sizeOfActualPool )
10862 : {
10863 0 : SgOmpBarrierStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10864 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10865 : {
10866 0 : new SgOmpBarrierStatement ( SgOmpBarrierStatementStorageArray[i] ) ;
10867 : }
10868 0 : delete [] SgOmpBarrierStatementStorageArray;
10869 : }
10870 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCriticalStatement ) ;
10871 0 : std::cout << " SgOmpCriticalStatement has size " << sizeOfActualPool << std::endl;
10872 0 : if ( 0 < sizeOfActualPool )
10873 : {
10874 0 : SgOmpCriticalStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10875 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10876 : {
10877 0 : new SgOmpCriticalStatement ( SgOmpCriticalStatementStorageArray[i] ) ;
10878 : }
10879 0 : delete [] SgOmpCriticalStatementStorageArray;
10880 : }
10881 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirFieldBodyStatement ) ;
10882 0 : std::cout << " SgUpirFieldBodyStatement has size " << sizeOfActualPool << std::endl;
10883 0 : if ( 0 < sizeOfActualPool )
10884 : {
10885 0 : SgUpirFieldBodyStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10886 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10887 : {
10888 0 : new SgUpirFieldBodyStatement ( SgUpirFieldBodyStatementStorageArray[i] ) ;
10889 : }
10890 0 : delete [] SgUpirFieldBodyStatementStorageArray;
10891 : }
10892 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirBodyStatement ) ;
10893 0 : std::cout << " SgUpirBodyStatement has size " << sizeOfActualPool << std::endl;
10894 0 : if ( 0 < sizeOfActualPool )
10895 : {
10896 0 : SgUpirBodyStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10897 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10898 : {
10899 0 : new SgUpirBodyStatement ( SgUpirBodyStatementStorageArray[i] ) ;
10900 : }
10901 0 : delete [] SgUpirBodyStatementStorageArray;
10902 : }
10903 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirFieldStatement ) ;
10904 0 : std::cout << " SgUpirFieldStatement has size " << sizeOfActualPool << std::endl;
10905 0 : if ( 0 < sizeOfActualPool )
10906 : {
10907 0 : SgUpirFieldStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10908 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10909 : {
10910 0 : new SgUpirFieldStatement ( SgUpirFieldStatementStorageArray[i] ) ;
10911 : }
10912 0 : delete [] SgUpirFieldStatementStorageArray;
10913 : }
10914 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDoStatement ) ;
10915 0 : std::cout << " SgOmpDoStatement has size " << sizeOfActualPool << std::endl;
10916 0 : if ( 0 < sizeOfActualPool )
10917 : {
10918 0 : SgOmpDoStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10919 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10920 : {
10921 0 : new SgOmpDoStatement ( SgOmpDoStatementStorageArray[i] ) ;
10922 : }
10923 0 : delete [] SgOmpDoStatementStorageArray;
10924 : }
10925 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpFlushStatement ) ;
10926 0 : std::cout << " SgOmpFlushStatement has size " << sizeOfActualPool << std::endl;
10927 0 : if ( 0 < sizeOfActualPool )
10928 : {
10929 0 : SgOmpFlushStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10930 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10931 : {
10932 0 : new SgOmpFlushStatement ( SgOmpFlushStatementStorageArray[i] ) ;
10933 : }
10934 0 : delete [] SgOmpFlushStatementStorageArray;
10935 : }
10936 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAllocateStatement ) ;
10937 0 : std::cout << " SgOmpAllocateStatement has size " << sizeOfActualPool << std::endl;
10938 0 : if ( 0 < sizeOfActualPool )
10939 : {
10940 0 : SgOmpAllocateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10941 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10942 : {
10943 0 : new SgOmpAllocateStatement ( SgOmpAllocateStatementStorageArray[i] ) ;
10944 : }
10945 0 : delete [] SgOmpAllocateStatementStorageArray;
10946 : }
10947 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDeclareSimdStatement ) ;
10948 0 : std::cout << " SgOmpDeclareSimdStatement has size " << sizeOfActualPool << std::endl;
10949 0 : if ( 0 < sizeOfActualPool )
10950 : {
10951 0 : SgOmpDeclareSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10952 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10953 : {
10954 0 : new SgOmpDeclareSimdStatement ( SgOmpDeclareSimdStatementStorageArray[i] ) ;
10955 : }
10956 0 : delete [] SgOmpDeclareSimdStatementStorageArray;
10957 : }
10958 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirWorksharingStatement ) ;
10959 0 : std::cout << " SgUpirWorksharingStatement has size " << sizeOfActualPool << std::endl;
10960 0 : if ( 0 < sizeOfActualPool )
10961 : {
10962 0 : SgUpirWorksharingStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10963 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10964 : {
10965 0 : new SgUpirWorksharingStatement ( SgUpirWorksharingStatementStorageArray[i] ) ;
10966 : }
10967 0 : delete [] SgUpirWorksharingStatementStorageArray;
10968 : }
10969 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpForSimdStatement ) ;
10970 0 : std::cout << " SgOmpForSimdStatement has size " << sizeOfActualPool << std::endl;
10971 0 : if ( 0 < sizeOfActualPool )
10972 : {
10973 0 : SgOmpForSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10974 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10975 : {
10976 0 : new SgOmpForSimdStatement ( SgOmpForSimdStatementStorageArray[i] ) ;
10977 : }
10978 0 : delete [] SgOmpForSimdStatementStorageArray;
10979 : }
10980 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMasterStatement ) ;
10981 0 : std::cout << " SgOmpMasterStatement has size " << sizeOfActualPool << std::endl;
10982 0 : if ( 0 < sizeOfActualPool )
10983 : {
10984 0 : SgOmpMasterStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10985 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10986 : {
10987 0 : new SgOmpMasterStatement ( SgOmpMasterStatementStorageArray[i] ) ;
10988 : }
10989 0 : delete [] SgOmpMasterStatementStorageArray;
10990 : }
10991 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskyieldStatement ) ;
10992 0 : std::cout << " SgOmpTaskyieldStatement has size " << sizeOfActualPool << std::endl;
10993 0 : if ( 0 < sizeOfActualPool )
10994 : {
10995 0 : SgOmpTaskyieldStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
10996 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
10997 : {
10998 0 : new SgOmpTaskyieldStatement ( SgOmpTaskyieldStatementStorageArray[i] ) ;
10999 : }
11000 0 : delete [] SgOmpTaskyieldStatementStorageArray;
11001 : }
11002 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMetadirectiveStatement ) ;
11003 0 : std::cout << " SgOmpMetadirectiveStatement has size " << sizeOfActualPool << std::endl;
11004 0 : if ( 0 < sizeOfActualPool )
11005 : {
11006 0 : SgOmpMetadirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11007 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11008 : {
11009 0 : new SgOmpMetadirectiveStatement ( SgOmpMetadirectiveStatementStorageArray[i] ) ;
11010 : }
11011 0 : delete [] SgOmpMetadirectiveStatementStorageArray;
11012 : }
11013 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpOrderedStatement ) ;
11014 0 : std::cout << " SgOmpOrderedStatement has size " << sizeOfActualPool << std::endl;
11015 0 : if ( 0 < sizeOfActualPool )
11016 : {
11017 0 : SgOmpOrderedStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11018 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11019 : {
11020 0 : new SgOmpOrderedStatement ( SgOmpOrderedStatementStorageArray[i] ) ;
11021 : }
11022 0 : delete [] SgOmpOrderedStatementStorageArray;
11023 : }
11024 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpOrderedDependStatement ) ;
11025 0 : std::cout << " SgOmpOrderedDependStatement has size " << sizeOfActualPool << std::endl;
11026 0 : if ( 0 < sizeOfActualPool )
11027 : {
11028 0 : SgOmpOrderedDependStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11029 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11030 : {
11031 0 : new SgOmpOrderedDependStatement ( SgOmpOrderedDependStatementStorageArray[i] ) ;
11032 : }
11033 0 : delete [] SgOmpOrderedDependStatementStorageArray;
11034 : }
11035 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirSpmdStatement ) ;
11036 0 : std::cout << " SgUpirSpmdStatement has size " << sizeOfActualPool << std::endl;
11037 0 : if ( 0 < sizeOfActualPool )
11038 : {
11039 0 : SgUpirSpmdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11040 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11041 : {
11042 0 : new SgUpirSpmdStatement ( SgUpirSpmdStatementStorageArray[i] ) ;
11043 : }
11044 0 : delete [] SgUpirSpmdStatementStorageArray;
11045 : }
11046 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsStatement ) ;
11047 0 : std::cout << " SgOmpTeamsStatement has size " << sizeOfActualPool << std::endl;
11048 0 : if ( 0 < sizeOfActualPool )
11049 : {
11050 0 : SgOmpTeamsStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11051 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11052 : {
11053 0 : new SgOmpTeamsStatement ( SgOmpTeamsStatementStorageArray[i] ) ;
11054 : }
11055 0 : delete [] SgOmpTeamsStatementStorageArray;
11056 : }
11057 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCancellationPointStatement ) ;
11058 0 : std::cout << " SgOmpCancellationPointStatement has size " << sizeOfActualPool << std::endl;
11059 0 : if ( 0 < sizeOfActualPool )
11060 : {
11061 0 : SgOmpCancellationPointStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11062 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11063 : {
11064 0 : new SgOmpCancellationPointStatement ( SgOmpCancellationPointStatementStorageArray[i] ) ;
11065 : }
11066 0 : delete [] SgOmpCancellationPointStatementStorageArray;
11067 : }
11068 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDeclareMapperStatement ) ;
11069 0 : std::cout << " SgOmpDeclareMapperStatement has size " << sizeOfActualPool << std::endl;
11070 0 : if ( 0 < sizeOfActualPool )
11071 : {
11072 0 : SgOmpDeclareMapperStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11073 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11074 : {
11075 0 : new SgOmpDeclareMapperStatement ( SgOmpDeclareMapperStatementStorageArray[i] ) ;
11076 : }
11077 0 : delete [] SgOmpDeclareMapperStatementStorageArray;
11078 : }
11079 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCancelStatement ) ;
11080 0 : std::cout << " SgOmpCancelStatement has size " << sizeOfActualPool << std::endl;
11081 0 : if ( 0 < sizeOfActualPool )
11082 : {
11083 0 : SgOmpCancelStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11084 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11085 : {
11086 0 : new SgOmpCancelStatement ( SgOmpCancelStatementStorageArray[i] ) ;
11087 : }
11088 0 : delete [] SgOmpCancelStatementStorageArray;
11089 : }
11090 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskgroupStatement ) ;
11091 0 : std::cout << " SgOmpTaskgroupStatement has size " << sizeOfActualPool << std::endl;
11092 0 : if ( 0 < sizeOfActualPool )
11093 : {
11094 0 : SgOmpTaskgroupStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11095 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11096 : {
11097 0 : new SgOmpTaskgroupStatement ( SgOmpTaskgroupStatementStorageArray[i] ) ;
11098 : }
11099 0 : delete [] SgOmpTaskgroupStatementStorageArray;
11100 : }
11101 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDepobjStatement ) ;
11102 0 : std::cout << " SgOmpDepobjStatement has size " << sizeOfActualPool << std::endl;
11103 0 : if ( 0 < sizeOfActualPool )
11104 : {
11105 0 : SgOmpDepobjStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11106 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11107 : {
11108 0 : new SgOmpDepobjStatement ( SgOmpDepobjStatementStorageArray[i] ) ;
11109 : }
11110 0 : delete [] SgOmpDepobjStatementStorageArray;
11111 : }
11112 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDistributeStatement ) ;
11113 0 : std::cout << " SgOmpDistributeStatement has size " << sizeOfActualPool << std::endl;
11114 0 : if ( 0 < sizeOfActualPool )
11115 : {
11116 0 : SgOmpDistributeStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11117 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11118 : {
11119 0 : new SgOmpDistributeStatement ( SgOmpDistributeStatementStorageArray[i] ) ;
11120 : }
11121 0 : delete [] SgOmpDistributeStatementStorageArray;
11122 : }
11123 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpLoopStatement ) ;
11124 0 : std::cout << " SgOmpLoopStatement has size " << sizeOfActualPool << std::endl;
11125 0 : if ( 0 < sizeOfActualPool )
11126 : {
11127 0 : SgOmpLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11128 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11129 : {
11130 0 : new SgOmpLoopStatement ( SgOmpLoopStatementStorageArray[i] ) ;
11131 : }
11132 0 : delete [] SgOmpLoopStatementStorageArray;
11133 : }
11134 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpScanStatement ) ;
11135 0 : std::cout << " SgOmpScanStatement has size " << sizeOfActualPool << std::endl;
11136 0 : if ( 0 < sizeOfActualPool )
11137 : {
11138 0 : SgOmpScanStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11139 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11140 : {
11141 0 : new SgOmpScanStatement ( SgOmpScanStatementStorageArray[i] ) ;
11142 : }
11143 0 : delete [] SgOmpScanStatementStorageArray;
11144 : }
11145 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskloopStatement ) ;
11146 0 : std::cout << " SgOmpTaskloopStatement has size " << sizeOfActualPool << std::endl;
11147 0 : if ( 0 < sizeOfActualPool )
11148 : {
11149 0 : SgOmpTaskloopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11150 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11151 : {
11152 0 : new SgOmpTaskloopStatement ( SgOmpTaskloopStatementStorageArray[i] ) ;
11153 : }
11154 0 : delete [] SgOmpTaskloopStatementStorageArray;
11155 : }
11156 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetEnterDataStatement ) ;
11157 0 : std::cout << " SgOmpTargetEnterDataStatement has size " << sizeOfActualPool << std::endl;
11158 0 : if ( 0 < sizeOfActualPool )
11159 : {
11160 0 : SgOmpTargetEnterDataStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11161 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11162 : {
11163 0 : new SgOmpTargetEnterDataStatement ( SgOmpTargetEnterDataStatementStorageArray[i] ) ;
11164 : }
11165 0 : delete [] SgOmpTargetEnterDataStatementStorageArray;
11166 : }
11167 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetExitDataStatement ) ;
11168 0 : std::cout << " SgOmpTargetExitDataStatement has size " << sizeOfActualPool << std::endl;
11169 0 : if ( 0 < sizeOfActualPool )
11170 : {
11171 0 : SgOmpTargetExitDataStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11172 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11173 : {
11174 0 : new SgOmpTargetExitDataStatement ( SgOmpTargetExitDataStatementStorageArray[i] ) ;
11175 : }
11176 0 : delete [] SgOmpTargetExitDataStatementStorageArray;
11177 : }
11178 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSectionStatement ) ;
11179 0 : std::cout << " SgOmpSectionStatement has size " << sizeOfActualPool << std::endl;
11180 0 : if ( 0 < sizeOfActualPool )
11181 : {
11182 0 : SgOmpSectionStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11183 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11184 : {
11185 0 : new SgOmpSectionStatement ( SgOmpSectionStatementStorageArray[i] ) ;
11186 : }
11187 0 : delete [] SgOmpSectionStatementStorageArray;
11188 : }
11189 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSectionsStatement ) ;
11190 0 : std::cout << " SgOmpSectionsStatement has size " << sizeOfActualPool << std::endl;
11191 0 : if ( 0 < sizeOfActualPool )
11192 : {
11193 0 : SgOmpSectionsStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11194 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11195 : {
11196 0 : new SgOmpSectionsStatement ( SgOmpSectionsStatementStorageArray[i] ) ;
11197 : }
11198 0 : delete [] SgOmpSectionsStatementStorageArray;
11199 : }
11200 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSingleStatement ) ;
11201 0 : std::cout << " SgOmpSingleStatement has size " << sizeOfActualPool << std::endl;
11202 0 : if ( 0 < sizeOfActualPool )
11203 : {
11204 0 : SgOmpSingleStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11205 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11206 : {
11207 0 : new SgOmpSingleStatement ( SgOmpSingleStatementStorageArray[i] ) ;
11208 : }
11209 0 : delete [] SgOmpSingleStatementStorageArray;
11210 : }
11211 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskStatement ) ;
11212 0 : std::cout << " SgOmpTaskStatement has size " << sizeOfActualPool << std::endl;
11213 0 : if ( 0 < sizeOfActualPool )
11214 : {
11215 0 : SgOmpTaskStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11216 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11217 : {
11218 0 : new SgOmpTaskStatement ( SgOmpTaskStatementStorageArray[i] ) ;
11219 : }
11220 0 : delete [] SgOmpTaskStatementStorageArray;
11221 : }
11222 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskwaitStatement ) ;
11223 0 : std::cout << " SgOmpTaskwaitStatement has size " << sizeOfActualPool << std::endl;
11224 0 : if ( 0 < sizeOfActualPool )
11225 : {
11226 0 : SgOmpTaskwaitStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11227 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11228 : {
11229 0 : new SgOmpTaskwaitStatement ( SgOmpTaskwaitStatementStorageArray[i] ) ;
11230 : }
11231 0 : delete [] SgOmpTaskwaitStatementStorageArray;
11232 : }
11233 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpThreadprivateStatement ) ;
11234 0 : std::cout << " SgOmpThreadprivateStatement has size " << sizeOfActualPool << std::endl;
11235 0 : if ( 0 < sizeOfActualPool )
11236 : {
11237 0 : SgOmpThreadprivateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11238 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11239 : {
11240 0 : new SgOmpThreadprivateStatement ( SgOmpThreadprivateStatementStorageArray[i] ) ;
11241 : }
11242 0 : delete [] SgOmpThreadprivateStatementStorageArray;
11243 : }
11244 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpWorkshareStatement ) ;
11245 0 : std::cout << " SgOmpWorkshareStatement has size " << sizeOfActualPool << std::endl;
11246 0 : if ( 0 < sizeOfActualPool )
11247 : {
11248 0 : SgOmpWorkshareStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11249 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11250 : {
11251 0 : new SgOmpWorkshareStatement ( SgOmpWorkshareStatementStorageArray[i] ) ;
11252 : }
11253 0 : delete [] SgOmpWorkshareStatementStorageArray;
11254 : }
11255 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirTaskStatement ) ;
11256 0 : std::cout << " SgUpirTaskStatement has size " << sizeOfActualPool << std::endl;
11257 0 : if ( 0 < sizeOfActualPool )
11258 : {
11259 0 : SgUpirTaskStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11260 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11261 : {
11262 0 : new SgUpirTaskStatement ( SgUpirTaskStatementStorageArray[i] ) ;
11263 : }
11264 0 : delete [] SgUpirTaskStatementStorageArray;
11265 : }
11266 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetDataStatement ) ;
11267 0 : std::cout << " SgOmpTargetDataStatement has size " << sizeOfActualPool << std::endl;
11268 0 : if ( 0 < sizeOfActualPool )
11269 : {
11270 0 : SgOmpTargetDataStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11271 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11272 : {
11273 0 : new SgOmpTargetDataStatement ( SgOmpTargetDataStatementStorageArray[i] ) ;
11274 : }
11275 0 : delete [] SgOmpTargetDataStatementStorageArray;
11276 : }
11277 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetParallelForStatement ) ;
11278 0 : std::cout << " SgOmpTargetParallelForStatement has size " << sizeOfActualPool << std::endl;
11279 0 : if ( 0 < sizeOfActualPool )
11280 : {
11281 0 : SgOmpTargetParallelForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11282 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11283 : {
11284 0 : new SgOmpTargetParallelForStatement ( SgOmpTargetParallelForStatementStorageArray[i] ) ;
11285 : }
11286 0 : delete [] SgOmpTargetParallelForStatementStorageArray;
11287 : }
11288 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetUpdateStatement ) ;
11289 0 : std::cout << " SgOmpTargetUpdateStatement has size " << sizeOfActualPool << std::endl;
11290 0 : if ( 0 < sizeOfActualPool )
11291 : {
11292 0 : SgOmpTargetUpdateStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11293 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11294 : {
11295 0 : new SgOmpTargetUpdateStatement ( SgOmpTargetUpdateStatementStorageArray[i] ) ;
11296 : }
11297 0 : delete [] SgOmpTargetUpdateStatementStorageArray;
11298 : }
11299 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpRequiresStatement ) ;
11300 0 : std::cout << " SgOmpRequiresStatement has size " << sizeOfActualPool << std::endl;
11301 0 : if ( 0 < sizeOfActualPool )
11302 : {
11303 0 : SgOmpRequiresStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11304 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11305 : {
11306 0 : new SgOmpRequiresStatement ( SgOmpRequiresStatementStorageArray[i] ) ;
11307 : }
11308 0 : delete [] SgOmpRequiresStatementStorageArray;
11309 : }
11310 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetParallelStatement ) ;
11311 0 : std::cout << " SgOmpTargetParallelStatement has size " << sizeOfActualPool << std::endl;
11312 0 : if ( 0 < sizeOfActualPool )
11313 : {
11314 0 : SgOmpTargetParallelStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11315 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11316 : {
11317 0 : new SgOmpTargetParallelStatement ( SgOmpTargetParallelStatementStorageArray[i] ) ;
11318 : }
11319 0 : delete [] SgOmpTargetParallelStatementStorageArray;
11320 : }
11321 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetParallelForSimdStatement ) ;
11322 0 : std::cout << " SgOmpTargetParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
11323 0 : if ( 0 < sizeOfActualPool )
11324 : {
11325 0 : SgOmpTargetParallelForSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11326 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11327 : {
11328 0 : new SgOmpTargetParallelForSimdStatement ( SgOmpTargetParallelForSimdStatementStorageArray[i] ) ;
11329 : }
11330 0 : delete [] SgOmpTargetParallelForSimdStatementStorageArray;
11331 : }
11332 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetParallelLoopStatement ) ;
11333 0 : std::cout << " SgOmpTargetParallelLoopStatement has size " << sizeOfActualPool << std::endl;
11334 0 : if ( 0 < sizeOfActualPool )
11335 : {
11336 0 : SgOmpTargetParallelLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11337 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11338 : {
11339 0 : new SgOmpTargetParallelLoopStatement ( SgOmpTargetParallelLoopStatementStorageArray[i] ) ;
11340 : }
11341 0 : delete [] SgOmpTargetParallelLoopStatementStorageArray;
11342 : }
11343 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetSimdStatement ) ;
11344 0 : std::cout << " SgOmpTargetSimdStatement has size " << sizeOfActualPool << std::endl;
11345 0 : if ( 0 < sizeOfActualPool )
11346 : {
11347 0 : SgOmpTargetSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11348 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11349 : {
11350 0 : new SgOmpTargetSimdStatement ( SgOmpTargetSimdStatementStorageArray[i] ) ;
11351 : }
11352 0 : delete [] SgOmpTargetSimdStatementStorageArray;
11353 : }
11354 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsStatement ) ;
11355 0 : std::cout << " SgOmpTargetTeamsStatement has size " << sizeOfActualPool << std::endl;
11356 0 : if ( 0 < sizeOfActualPool )
11357 : {
11358 0 : SgOmpTargetTeamsStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11359 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11360 : {
11361 0 : new SgOmpTargetTeamsStatement ( SgOmpTargetTeamsStatementStorageArray[i] ) ;
11362 : }
11363 0 : delete [] SgOmpTargetTeamsStatementStorageArray;
11364 : }
11365 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsDistributeStatement ) ;
11366 0 : std::cout << " SgOmpTargetTeamsDistributeStatement has size " << sizeOfActualPool << std::endl;
11367 0 : if ( 0 < sizeOfActualPool )
11368 : {
11369 0 : SgOmpTargetTeamsDistributeStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11370 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11371 : {
11372 0 : new SgOmpTargetTeamsDistributeStatement ( SgOmpTargetTeamsDistributeStatementStorageArray[i] ) ;
11373 : }
11374 0 : delete [] SgOmpTargetTeamsDistributeStatementStorageArray;
11375 : }
11376 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsDistributeSimdStatement ) ;
11377 0 : std::cout << " SgOmpTargetTeamsDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
11378 0 : if ( 0 < sizeOfActualPool )
11379 : {
11380 0 : SgOmpTargetTeamsDistributeSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11381 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11382 : {
11383 0 : new SgOmpTargetTeamsDistributeSimdStatement ( SgOmpTargetTeamsDistributeSimdStatementStorageArray[i] ) ;
11384 : }
11385 0 : delete [] SgOmpTargetTeamsDistributeSimdStatementStorageArray;
11386 : }
11387 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsLoopStatement ) ;
11388 0 : std::cout << " SgOmpTargetTeamsLoopStatement has size " << sizeOfActualPool << std::endl;
11389 0 : if ( 0 < sizeOfActualPool )
11390 : {
11391 0 : SgOmpTargetTeamsLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11392 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11393 : {
11394 0 : new SgOmpTargetTeamsLoopStatement ( SgOmpTargetTeamsLoopStatementStorageArray[i] ) ;
11395 : }
11396 0 : delete [] SgOmpTargetTeamsLoopStatementStorageArray;
11397 : }
11398 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsDistributeParallelForStatement ) ;
11399 0 : std::cout << " SgOmpTargetTeamsDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
11400 0 : if ( 0 < sizeOfActualPool )
11401 : {
11402 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11403 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11404 : {
11405 0 : new SgOmpTargetTeamsDistributeParallelForStatement ( SgOmpTargetTeamsDistributeParallelForStatementStorageArray[i] ) ;
11406 : }
11407 0 : delete [] SgOmpTargetTeamsDistributeParallelForStatementStorageArray;
11408 : }
11409 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTargetTeamsDistributeParallelForSimdStatement ) ;
11410 0 : std::cout << " SgOmpTargetTeamsDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
11411 0 : if ( 0 < sizeOfActualPool )
11412 : {
11413 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11414 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11415 : {
11416 0 : new SgOmpTargetTeamsDistributeParallelForSimdStatement ( SgOmpTargetTeamsDistributeParallelForSimdStatementStorageArray[i] ) ;
11417 : }
11418 0 : delete [] SgOmpTargetTeamsDistributeParallelForSimdStatementStorageArray;
11419 : }
11420 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDistributeSimdStatement ) ;
11421 0 : std::cout << " SgOmpDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
11422 0 : if ( 0 < sizeOfActualPool )
11423 : {
11424 0 : SgOmpDistributeSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11425 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11426 : {
11427 0 : new SgOmpDistributeSimdStatement ( SgOmpDistributeSimdStatementStorageArray[i] ) ;
11428 : }
11429 0 : delete [] SgOmpDistributeSimdStatementStorageArray;
11430 : }
11431 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDistributeParallelForStatement ) ;
11432 0 : std::cout << " SgOmpDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
11433 0 : if ( 0 < sizeOfActualPool )
11434 : {
11435 0 : SgOmpDistributeParallelForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11436 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11437 : {
11438 0 : new SgOmpDistributeParallelForStatement ( SgOmpDistributeParallelForStatementStorageArray[i] ) ;
11439 : }
11440 0 : delete [] SgOmpDistributeParallelForStatementStorageArray;
11441 : }
11442 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDistributeParallelForSimdStatement ) ;
11443 0 : std::cout << " SgOmpDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
11444 0 : if ( 0 < sizeOfActualPool )
11445 : {
11446 0 : SgOmpDistributeParallelForSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11447 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11448 : {
11449 0 : new SgOmpDistributeParallelForSimdStatement ( SgOmpDistributeParallelForSimdStatementStorageArray[i] ) ;
11450 : }
11451 0 : delete [] SgOmpDistributeParallelForSimdStatementStorageArray;
11452 : }
11453 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskloopSimdStatement ) ;
11454 0 : std::cout << " SgOmpTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
11455 0 : if ( 0 < sizeOfActualPool )
11456 : {
11457 0 : SgOmpTaskloopSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11458 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11459 : {
11460 0 : new SgOmpTaskloopSimdStatement ( SgOmpTaskloopSimdStatementStorageArray[i] ) ;
11461 : }
11462 0 : delete [] SgOmpTaskloopSimdStatementStorageArray;
11463 : }
11464 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMasterTaskloopSimdStatement ) ;
11465 0 : std::cout << " SgOmpMasterTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
11466 0 : if ( 0 < sizeOfActualPool )
11467 : {
11468 0 : SgOmpMasterTaskloopSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11469 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11470 : {
11471 0 : new SgOmpMasterTaskloopSimdStatement ( SgOmpMasterTaskloopSimdStatementStorageArray[i] ) ;
11472 : }
11473 0 : delete [] SgOmpMasterTaskloopSimdStatementStorageArray;
11474 : }
11475 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpParallelMasterTaskloopStatement ) ;
11476 0 : std::cout << " SgOmpParallelMasterTaskloopStatement has size " << sizeOfActualPool << std::endl;
11477 0 : if ( 0 < sizeOfActualPool )
11478 : {
11479 0 : SgOmpParallelMasterTaskloopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11480 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11481 : {
11482 0 : new SgOmpParallelMasterTaskloopStatement ( SgOmpParallelMasterTaskloopStatementStorageArray[i] ) ;
11483 : }
11484 0 : delete [] SgOmpParallelMasterTaskloopStatementStorageArray;
11485 : }
11486 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpParallelMasterTaskloopSimdStatement ) ;
11487 0 : std::cout << " SgOmpParallelMasterTaskloopSimdStatement has size " << sizeOfActualPool << std::endl;
11488 0 : if ( 0 < sizeOfActualPool )
11489 : {
11490 0 : SgOmpParallelMasterTaskloopSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11491 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11492 : {
11493 0 : new SgOmpParallelMasterTaskloopSimdStatement ( SgOmpParallelMasterTaskloopSimdStatementStorageArray[i] ) ;
11494 : }
11495 0 : delete [] SgOmpParallelMasterTaskloopSimdStatementStorageArray;
11496 : }
11497 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsDistributeStatement ) ;
11498 0 : std::cout << " SgOmpTeamsDistributeStatement has size " << sizeOfActualPool << std::endl;
11499 0 : if ( 0 < sizeOfActualPool )
11500 : {
11501 0 : SgOmpTeamsDistributeStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11502 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11503 : {
11504 0 : new SgOmpTeamsDistributeStatement ( SgOmpTeamsDistributeStatementStorageArray[i] ) ;
11505 : }
11506 0 : delete [] SgOmpTeamsDistributeStatementStorageArray;
11507 : }
11508 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsDistributeSimdStatement ) ;
11509 0 : std::cout << " SgOmpTeamsDistributeSimdStatement has size " << sizeOfActualPool << std::endl;
11510 0 : if ( 0 < sizeOfActualPool )
11511 : {
11512 0 : SgOmpTeamsDistributeSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11513 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11514 : {
11515 0 : new SgOmpTeamsDistributeSimdStatement ( SgOmpTeamsDistributeSimdStatementStorageArray[i] ) ;
11516 : }
11517 0 : delete [] SgOmpTeamsDistributeSimdStatementStorageArray;
11518 : }
11519 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsDistributeParallelForStatement ) ;
11520 0 : std::cout << " SgOmpTeamsDistributeParallelForStatement has size " << sizeOfActualPool << std::endl;
11521 0 : if ( 0 < sizeOfActualPool )
11522 : {
11523 0 : SgOmpTeamsDistributeParallelForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11524 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11525 : {
11526 0 : new SgOmpTeamsDistributeParallelForStatement ( SgOmpTeamsDistributeParallelForStatementStorageArray[i] ) ;
11527 : }
11528 0 : delete [] SgOmpTeamsDistributeParallelForStatementStorageArray;
11529 : }
11530 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsDistributeParallelForSimdStatement ) ;
11531 0 : std::cout << " SgOmpTeamsDistributeParallelForSimdStatement has size " << sizeOfActualPool << std::endl;
11532 0 : if ( 0 < sizeOfActualPool )
11533 : {
11534 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11535 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11536 : {
11537 0 : new SgOmpTeamsDistributeParallelForSimdStatement ( SgOmpTeamsDistributeParallelForSimdStatementStorageArray[i] ) ;
11538 : }
11539 0 : delete [] SgOmpTeamsDistributeParallelForSimdStatementStorageArray;
11540 : }
11541 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTeamsLoopStatement ) ;
11542 0 : std::cout << " SgOmpTeamsLoopStatement has size " << sizeOfActualPool << std::endl;
11543 0 : if ( 0 < sizeOfActualPool )
11544 : {
11545 0 : SgOmpTeamsLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11546 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11547 : {
11548 0 : new SgOmpTeamsLoopStatement ( SgOmpTeamsLoopStatementStorageArray[i] ) ;
11549 : }
11550 0 : delete [] SgOmpTeamsLoopStatementStorageArray;
11551 : }
11552 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpParallelLoopStatement ) ;
11553 0 : std::cout << " SgOmpParallelLoopStatement has size " << sizeOfActualPool << std::endl;
11554 0 : if ( 0 < sizeOfActualPool )
11555 : {
11556 0 : SgOmpParallelLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11557 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11558 : {
11559 0 : new SgOmpParallelLoopStatement ( SgOmpParallelLoopStatementStorageArray[i] ) ;
11560 : }
11561 0 : delete [] SgOmpParallelLoopStatementStorageArray;
11562 : }
11563 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpParallelMasterStatement ) ;
11564 0 : std::cout << " SgOmpParallelMasterStatement has size " << sizeOfActualPool << std::endl;
11565 0 : if ( 0 < sizeOfActualPool )
11566 : {
11567 0 : SgOmpParallelMasterStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11568 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11569 : {
11570 0 : new SgOmpParallelMasterStatement ( SgOmpParallelMasterStatementStorageArray[i] ) ;
11571 : }
11572 0 : delete [] SgOmpParallelMasterStatementStorageArray;
11573 : }
11574 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMasterTaskloopStatement ) ;
11575 0 : std::cout << " SgOmpMasterTaskloopStatement has size " << sizeOfActualPool << std::endl;
11576 0 : if ( 0 < sizeOfActualPool )
11577 : {
11578 0 : SgOmpMasterTaskloopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11579 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11580 : {
11581 0 : new SgOmpMasterTaskloopStatement ( SgOmpMasterTaskloopStatementStorageArray[i] ) ;
11582 : }
11583 0 : delete [] SgOmpMasterTaskloopStatementStorageArray;
11584 : }
11585 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUnrollStatement ) ;
11586 0 : std::cout << " SgOmpUnrollStatement has size " << sizeOfActualPool << std::endl;
11587 0 : if ( 0 < sizeOfActualPool )
11588 : {
11589 0 : SgOmpUnrollStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11590 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11591 : {
11592 0 : new SgOmpUnrollStatement ( SgOmpUnrollStatementStorageArray[i] ) ;
11593 : }
11594 0 : delete [] SgOmpUnrollStatementStorageArray;
11595 : }
11596 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTileStatement ) ;
11597 0 : std::cout << " SgOmpTileStatement has size " << sizeOfActualPool << std::endl;
11598 0 : if ( 0 < sizeOfActualPool )
11599 : {
11600 0 : SgOmpTileStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11601 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11602 : {
11603 0 : new SgOmpTileStatement ( SgOmpTileStatementStorageArray[i] ) ;
11604 : }
11605 0 : delete [] SgOmpTileStatementStorageArray;
11606 : }
11607 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirSimdStatement ) ;
11608 0 : std::cout << " SgUpirSimdStatement has size " << sizeOfActualPool << std::endl;
11609 0 : if ( 0 < sizeOfActualPool )
11610 : {
11611 0 : SgUpirSimdStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11612 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11613 : {
11614 0 : new SgUpirSimdStatement ( SgUpirSimdStatementStorageArray[i] ) ;
11615 : }
11616 0 : delete [] SgUpirSimdStatementStorageArray;
11617 : }
11618 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirBaseStatement ) ;
11619 0 : std::cout << " SgUpirBaseStatement has size " << sizeOfActualPool << std::endl;
11620 0 : if ( 0 < sizeOfActualPool )
11621 : {
11622 0 : SgUpirBaseStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11623 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11624 : {
11625 0 : new SgUpirBaseStatement ( SgUpirBaseStatementStorageArray[i] ) ;
11626 : }
11627 0 : delete [] SgUpirBaseStatementStorageArray;
11628 : }
11629 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirLoopStatement ) ;
11630 0 : std::cout << " SgUpirLoopStatement has size " << sizeOfActualPool << std::endl;
11631 0 : if ( 0 < sizeOfActualPool )
11632 : {
11633 0 : SgUpirLoopStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11634 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11635 : {
11636 0 : new SgUpirLoopStatement ( SgUpirLoopStatementStorageArray[i] ) ;
11637 : }
11638 0 : delete [] SgUpirLoopStatementStorageArray;
11639 : }
11640 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirLoopParallelStatement ) ;
11641 0 : std::cout << " SgUpirLoopParallelStatement has size " << sizeOfActualPool << std::endl;
11642 0 : if ( 0 < sizeOfActualPool )
11643 : {
11644 0 : SgUpirLoopParallelStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11645 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11646 : {
11647 0 : new SgUpirLoopParallelStatement ( SgUpirLoopParallelStatementStorageArray[i] ) ;
11648 : }
11649 0 : delete [] SgUpirLoopParallelStatementStorageArray;
11650 : }
11651 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirSyncStatement ) ;
11652 0 : std::cout << " SgUpirSyncStatement has size " << sizeOfActualPool << std::endl;
11653 0 : if ( 0 < sizeOfActualPool )
11654 : {
11655 0 : SgUpirSyncStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11656 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11657 : {
11658 0 : new SgUpirSyncStatement ( SgUpirSyncStatementStorageArray[i] ) ;
11659 : }
11660 0 : delete [] SgUpirSyncStatementStorageArray;
11661 : }
11662 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpClause ) ;
11663 0 : std::cout << " SgOmpClause has size " << sizeOfActualPool << std::endl;
11664 0 : if ( 0 < sizeOfActualPool )
11665 : {
11666 0 : SgOmpClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11667 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11668 : {
11669 0 : new SgOmpClause ( SgOmpClauseStorageArray[i] ) ;
11670 : }
11671 0 : delete [] SgOmpClauseStorageArray;
11672 : }
11673 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAllocateClause ) ;
11674 0 : std::cout << " SgOmpAllocateClause has size " << sizeOfActualPool << std::endl;
11675 0 : if ( 0 < sizeOfActualPool )
11676 : {
11677 0 : SgOmpAllocateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11678 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11679 : {
11680 0 : new SgOmpAllocateClause ( SgOmpAllocateClauseStorageArray[i] ) ;
11681 : }
11682 0 : delete [] SgOmpAllocateClauseStorageArray;
11683 : }
11684 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAllocatorClause ) ;
11685 0 : std::cout << " SgOmpAllocatorClause has size " << sizeOfActualPool << std::endl;
11686 0 : if ( 0 < sizeOfActualPool )
11687 : {
11688 0 : SgOmpAllocatorClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11689 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11690 : {
11691 0 : new SgOmpAllocatorClause ( SgOmpAllocatorClauseStorageArray[i] ) ;
11692 : }
11693 0 : delete [] SgOmpAllocatorClauseStorageArray;
11694 : }
11695 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUsesAllocatorsClause ) ;
11696 0 : std::cout << " SgOmpUsesAllocatorsClause has size " << sizeOfActualPool << std::endl;
11697 0 : if ( 0 < sizeOfActualPool )
11698 : {
11699 0 : SgOmpUsesAllocatorsClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11700 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11701 : {
11702 0 : new SgOmpUsesAllocatorsClause ( SgOmpUsesAllocatorsClauseStorageArray[i] ) ;
11703 : }
11704 0 : delete [] SgOmpUsesAllocatorsClauseStorageArray;
11705 : }
11706 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUsesAllocatorsDefination ) ;
11707 0 : std::cout << " SgOmpUsesAllocatorsDefination has size " << sizeOfActualPool << std::endl;
11708 0 : if ( 0 < sizeOfActualPool )
11709 : {
11710 0 : SgOmpUsesAllocatorsDefinationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11711 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11712 : {
11713 0 : new SgOmpUsesAllocatorsDefination ( SgOmpUsesAllocatorsDefinationStorageArray[i] ) ;
11714 : }
11715 0 : delete [] SgOmpUsesAllocatorsDefinationStorageArray;
11716 : }
11717 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpToClause ) ;
11718 0 : std::cout << " SgOmpToClause has size " << sizeOfActualPool << std::endl;
11719 0 : if ( 0 < sizeOfActualPool )
11720 : {
11721 0 : SgOmpToClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11722 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11723 : {
11724 0 : new SgOmpToClause ( SgOmpToClauseStorageArray[i] ) ;
11725 : }
11726 0 : delete [] SgOmpToClauseStorageArray;
11727 : }
11728 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpFromClause ) ;
11729 0 : std::cout << " SgOmpFromClause has size " << sizeOfActualPool << std::endl;
11730 0 : if ( 0 < sizeOfActualPool )
11731 : {
11732 0 : SgOmpFromClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11733 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11734 : {
11735 0 : new SgOmpFromClause ( SgOmpFromClauseStorageArray[i] ) ;
11736 : }
11737 0 : delete [] SgOmpFromClauseStorageArray;
11738 : }
11739 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpThreadsClause ) ;
11740 0 : std::cout << " SgOmpThreadsClause has size " << sizeOfActualPool << std::endl;
11741 0 : if ( 0 < sizeOfActualPool )
11742 : {
11743 0 : SgOmpThreadsClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11744 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11745 : {
11746 0 : new SgOmpThreadsClause ( SgOmpThreadsClauseStorageArray[i] ) ;
11747 : }
11748 0 : delete [] SgOmpThreadsClauseStorageArray;
11749 : }
11750 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSimdClause ) ;
11751 0 : std::cout << " SgOmpSimdClause has size " << sizeOfActualPool << std::endl;
11752 0 : if ( 0 < sizeOfActualPool )
11753 : {
11754 0 : SgOmpSimdClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11755 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11756 : {
11757 0 : new SgOmpSimdClause ( SgOmpSimdClauseStorageArray[i] ) ;
11758 : }
11759 0 : delete [] SgOmpSimdClauseStorageArray;
11760 : }
11761 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpBeginClause ) ;
11762 0 : std::cout << " SgOmpBeginClause has size " << sizeOfActualPool << std::endl;
11763 0 : if ( 0 < sizeOfActualPool )
11764 : {
11765 0 : SgOmpBeginClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11766 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11767 : {
11768 0 : new SgOmpBeginClause ( SgOmpBeginClauseStorageArray[i] ) ;
11769 : }
11770 0 : delete [] SgOmpBeginClauseStorageArray;
11771 : }
11772 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCollapseClause ) ;
11773 0 : std::cout << " SgOmpCollapseClause has size " << sizeOfActualPool << std::endl;
11774 0 : if ( 0 < sizeOfActualPool )
11775 : {
11776 0 : SgOmpCollapseClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11777 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11778 : {
11779 0 : new SgOmpCollapseClause ( SgOmpCollapseClauseStorageArray[i] ) ;
11780 : }
11781 0 : delete [] SgOmpCollapseClauseStorageArray;
11782 : }
11783 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCopyinClause ) ;
11784 0 : std::cout << " SgOmpCopyinClause has size " << sizeOfActualPool << std::endl;
11785 0 : if ( 0 < sizeOfActualPool )
11786 : {
11787 0 : SgOmpCopyinClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11788 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11789 : {
11790 0 : new SgOmpCopyinClause ( SgOmpCopyinClauseStorageArray[i] ) ;
11791 : }
11792 0 : delete [] SgOmpCopyinClauseStorageArray;
11793 : }
11794 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCopyprivateClause ) ;
11795 0 : std::cout << " SgOmpCopyprivateClause has size " << sizeOfActualPool << std::endl;
11796 0 : if ( 0 < sizeOfActualPool )
11797 : {
11798 0 : SgOmpCopyprivateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11799 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11800 : {
11801 0 : new SgOmpCopyprivateClause ( SgOmpCopyprivateClauseStorageArray[i] ) ;
11802 : }
11803 0 : delete [] SgOmpCopyprivateClauseStorageArray;
11804 : }
11805 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDefaultClause ) ;
11806 0 : std::cout << " SgOmpDefaultClause has size " << sizeOfActualPool << std::endl;
11807 0 : if ( 0 < sizeOfActualPool )
11808 : {
11809 0 : SgOmpDefaultClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11810 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11811 : {
11812 0 : new SgOmpDefaultClause ( SgOmpDefaultClauseStorageArray[i] ) ;
11813 : }
11814 0 : delete [] SgOmpDefaultClauseStorageArray;
11815 : }
11816 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpEndClause ) ;
11817 0 : std::cout << " SgOmpEndClause has size " << sizeOfActualPool << std::endl;
11818 0 : if ( 0 < sizeOfActualPool )
11819 : {
11820 0 : SgOmpEndClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11821 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11822 : {
11823 0 : new SgOmpEndClause ( SgOmpEndClauseStorageArray[i] ) ;
11824 : }
11825 0 : delete [] SgOmpEndClauseStorageArray;
11826 : }
11827 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpExpressionClause ) ;
11828 0 : std::cout << " SgOmpExpressionClause has size " << sizeOfActualPool << std::endl;
11829 0 : if ( 0 < sizeOfActualPool )
11830 : {
11831 0 : SgOmpExpressionClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11832 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11833 : {
11834 0 : new SgOmpExpressionClause ( SgOmpExpressionClauseStorageArray[i] ) ;
11835 : }
11836 0 : delete [] SgOmpExpressionClauseStorageArray;
11837 : }
11838 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpFirstprivateClause ) ;
11839 0 : std::cout << " SgOmpFirstprivateClause has size " << sizeOfActualPool << std::endl;
11840 0 : if ( 0 < sizeOfActualPool )
11841 : {
11842 0 : SgOmpFirstprivateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11843 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11844 : {
11845 0 : new SgOmpFirstprivateClause ( SgOmpFirstprivateClauseStorageArray[i] ) ;
11846 : }
11847 0 : delete [] SgOmpFirstprivateClauseStorageArray;
11848 : }
11849 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpIfClause ) ;
11850 0 : std::cout << " SgOmpIfClause has size " << sizeOfActualPool << std::endl;
11851 0 : if ( 0 < sizeOfActualPool )
11852 : {
11853 0 : SgOmpIfClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11854 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11855 : {
11856 0 : new SgOmpIfClause ( SgOmpIfClauseStorageArray[i] ) ;
11857 : }
11858 0 : delete [] SgOmpIfClauseStorageArray;
11859 : }
11860 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpFinalClause ) ;
11861 0 : std::cout << " SgOmpFinalClause has size " << sizeOfActualPool << std::endl;
11862 0 : if ( 0 < sizeOfActualPool )
11863 : {
11864 0 : SgOmpFinalClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11865 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11866 : {
11867 0 : new SgOmpFinalClause ( SgOmpFinalClauseStorageArray[i] ) ;
11868 : }
11869 0 : delete [] SgOmpFinalClauseStorageArray;
11870 : }
11871 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpPriorityClause ) ;
11872 0 : std::cout << " SgOmpPriorityClause has size " << sizeOfActualPool << std::endl;
11873 0 : if ( 0 < sizeOfActualPool )
11874 : {
11875 0 : SgOmpPriorityClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11876 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11877 : {
11878 0 : new SgOmpPriorityClause ( SgOmpPriorityClauseStorageArray[i] ) ;
11879 : }
11880 0 : delete [] SgOmpPriorityClauseStorageArray;
11881 : }
11882 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDeviceClause ) ;
11883 0 : std::cout << " SgOmpDeviceClause has size " << sizeOfActualPool << std::endl;
11884 0 : if ( 0 < sizeOfActualPool )
11885 : {
11886 0 : SgOmpDeviceClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11887 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11888 : {
11889 0 : new SgOmpDeviceClause ( SgOmpDeviceClauseStorageArray[i] ) ;
11890 : }
11891 0 : delete [] SgOmpDeviceClauseStorageArray;
11892 : }
11893 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpLastprivateClause ) ;
11894 0 : std::cout << " SgOmpLastprivateClause has size " << sizeOfActualPool << std::endl;
11895 0 : if ( 0 < sizeOfActualPool )
11896 : {
11897 0 : SgOmpLastprivateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11898 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11899 : {
11900 0 : new SgOmpLastprivateClause ( SgOmpLastprivateClauseStorageArray[i] ) ;
11901 : }
11902 0 : delete [] SgOmpLastprivateClauseStorageArray;
11903 : }
11904 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNowaitClause ) ;
11905 0 : std::cout << " SgOmpNowaitClause has size " << sizeOfActualPool << std::endl;
11906 0 : if ( 0 < sizeOfActualPool )
11907 : {
11908 0 : SgOmpNowaitClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11909 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11910 : {
11911 0 : new SgOmpNowaitClause ( SgOmpNowaitClauseStorageArray[i] ) ;
11912 : }
11913 0 : delete [] SgOmpNowaitClauseStorageArray;
11914 : }
11915 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpReadClause ) ;
11916 0 : std::cout << " SgOmpReadClause has size " << sizeOfActualPool << std::endl;
11917 0 : if ( 0 < sizeOfActualPool )
11918 : {
11919 0 : SgOmpReadClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11920 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11921 : {
11922 0 : new SgOmpReadClause ( SgOmpReadClauseStorageArray[i] ) ;
11923 : }
11924 0 : delete [] SgOmpReadClauseStorageArray;
11925 : }
11926 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpWriteClause ) ;
11927 0 : std::cout << " SgOmpWriteClause has size " << sizeOfActualPool << std::endl;
11928 0 : if ( 0 < sizeOfActualPool )
11929 : {
11930 0 : SgOmpWriteClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11931 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11932 : {
11933 0 : new SgOmpWriteClause ( SgOmpWriteClauseStorageArray[i] ) ;
11934 : }
11935 0 : delete [] SgOmpWriteClauseStorageArray;
11936 : }
11937 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUpdateClause ) ;
11938 0 : std::cout << " SgOmpUpdateClause has size " << sizeOfActualPool << std::endl;
11939 0 : if ( 0 < sizeOfActualPool )
11940 : {
11941 0 : SgOmpUpdateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11942 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11943 : {
11944 0 : new SgOmpUpdateClause ( SgOmpUpdateClauseStorageArray[i] ) ;
11945 : }
11946 0 : delete [] SgOmpUpdateClauseStorageArray;
11947 : }
11948 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDepobjUpdateClause ) ;
11949 0 : std::cout << " SgOmpDepobjUpdateClause has size " << sizeOfActualPool << std::endl;
11950 0 : if ( 0 < sizeOfActualPool )
11951 : {
11952 0 : SgOmpDepobjUpdateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11953 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11954 : {
11955 0 : new SgOmpDepobjUpdateClause ( SgOmpDepobjUpdateClauseStorageArray[i] ) ;
11956 : }
11957 0 : delete [] SgOmpDepobjUpdateClauseStorageArray;
11958 : }
11959 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDestroyClause ) ;
11960 0 : std::cout << " SgOmpDestroyClause has size " << sizeOfActualPool << std::endl;
11961 0 : if ( 0 < sizeOfActualPool )
11962 : {
11963 0 : SgOmpDestroyClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11964 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11965 : {
11966 0 : new SgOmpDestroyClause ( SgOmpDestroyClauseStorageArray[i] ) ;
11967 : }
11968 0 : delete [] SgOmpDestroyClauseStorageArray;
11969 : }
11970 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpCaptureClause ) ;
11971 0 : std::cout << " SgOmpCaptureClause has size " << sizeOfActualPool << std::endl;
11972 0 : if ( 0 < sizeOfActualPool )
11973 : {
11974 0 : SgOmpCaptureClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11975 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11976 : {
11977 0 : new SgOmpCaptureClause ( SgOmpCaptureClauseStorageArray[i] ) ;
11978 : }
11979 0 : delete [] SgOmpCaptureClauseStorageArray;
11980 : }
11981 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSeqCstClause ) ;
11982 0 : std::cout << " SgOmpSeqCstClause has size " << sizeOfActualPool << std::endl;
11983 0 : if ( 0 < sizeOfActualPool )
11984 : {
11985 0 : SgOmpSeqCstClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11986 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11987 : {
11988 0 : new SgOmpSeqCstClause ( SgOmpSeqCstClauseStorageArray[i] ) ;
11989 : }
11990 0 : delete [] SgOmpSeqCstClauseStorageArray;
11991 : }
11992 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAcqRelClause ) ;
11993 0 : std::cout << " SgOmpAcqRelClause has size " << sizeOfActualPool << std::endl;
11994 0 : if ( 0 < sizeOfActualPool )
11995 : {
11996 0 : SgOmpAcqRelClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
11997 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
11998 : {
11999 0 : new SgOmpAcqRelClause ( SgOmpAcqRelClauseStorageArray[i] ) ;
12000 : }
12001 0 : delete [] SgOmpAcqRelClauseStorageArray;
12002 : }
12003 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpReleaseClause ) ;
12004 0 : std::cout << " SgOmpReleaseClause has size " << sizeOfActualPool << std::endl;
12005 0 : if ( 0 < sizeOfActualPool )
12006 : {
12007 0 : SgOmpReleaseClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12008 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12009 : {
12010 0 : new SgOmpReleaseClause ( SgOmpReleaseClauseStorageArray[i] ) ;
12011 : }
12012 0 : delete [] SgOmpReleaseClauseStorageArray;
12013 : }
12014 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAcquireClause ) ;
12015 0 : std::cout << " SgOmpAcquireClause has size " << sizeOfActualPool << std::endl;
12016 0 : if ( 0 < sizeOfActualPool )
12017 : {
12018 0 : SgOmpAcquireClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12019 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12020 : {
12021 0 : new SgOmpAcquireClause ( SgOmpAcquireClauseStorageArray[i] ) ;
12022 : }
12023 0 : delete [] SgOmpAcquireClauseStorageArray;
12024 : }
12025 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpReverseOffloadClause ) ;
12026 0 : std::cout << " SgOmpReverseOffloadClause has size " << sizeOfActualPool << std::endl;
12027 0 : if ( 0 < sizeOfActualPool )
12028 : {
12029 0 : SgOmpReverseOffloadClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12030 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12031 : {
12032 0 : new SgOmpReverseOffloadClause ( SgOmpReverseOffloadClauseStorageArray[i] ) ;
12033 : }
12034 0 : delete [] SgOmpReverseOffloadClauseStorageArray;
12035 : }
12036 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUnifiedAddressClause ) ;
12037 0 : std::cout << " SgOmpUnifiedAddressClause has size " << sizeOfActualPool << std::endl;
12038 0 : if ( 0 < sizeOfActualPool )
12039 : {
12040 0 : SgOmpUnifiedAddressClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12041 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12042 : {
12043 0 : new SgOmpUnifiedAddressClause ( SgOmpUnifiedAddressClauseStorageArray[i] ) ;
12044 : }
12045 0 : delete [] SgOmpUnifiedAddressClauseStorageArray;
12046 : }
12047 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUnifiedSharedMemoryClause ) ;
12048 0 : std::cout << " SgOmpUnifiedSharedMemoryClause has size " << sizeOfActualPool << std::endl;
12049 0 : if ( 0 < sizeOfActualPool )
12050 : {
12051 0 : SgOmpUnifiedSharedMemoryClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12052 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12053 : {
12054 0 : new SgOmpUnifiedSharedMemoryClause ( SgOmpUnifiedSharedMemoryClauseStorageArray[i] ) ;
12055 : }
12056 0 : delete [] SgOmpUnifiedSharedMemoryClauseStorageArray;
12057 : }
12058 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDynamicAllocatorsClause ) ;
12059 0 : std::cout << " SgOmpDynamicAllocatorsClause has size " << sizeOfActualPool << std::endl;
12060 0 : if ( 0 < sizeOfActualPool )
12061 : {
12062 0 : SgOmpDynamicAllocatorsClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12063 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12064 : {
12065 0 : new SgOmpDynamicAllocatorsClause ( SgOmpDynamicAllocatorsClauseStorageArray[i] ) ;
12066 : }
12067 0 : delete [] SgOmpDynamicAllocatorsClauseStorageArray;
12068 : }
12069 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAtomicDefaultMemOrderClause ) ;
12070 0 : std::cout << " SgOmpAtomicDefaultMemOrderClause has size " << sizeOfActualPool << std::endl;
12071 0 : if ( 0 < sizeOfActualPool )
12072 : {
12073 0 : SgOmpAtomicDefaultMemOrderClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12074 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12075 : {
12076 0 : new SgOmpAtomicDefaultMemOrderClause ( SgOmpAtomicDefaultMemOrderClauseStorageArray[i] ) ;
12077 : }
12078 0 : delete [] SgOmpAtomicDefaultMemOrderClauseStorageArray;
12079 : }
12080 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpExtImplementationDefinedRequirementClause ) ;
12081 0 : std::cout << " SgOmpExtImplementationDefinedRequirementClause has size " << sizeOfActualPool << std::endl;
12082 0 : if ( 0 < sizeOfActualPool )
12083 : {
12084 0 : SgOmpExtImplementationDefinedRequirementClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12085 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12086 : {
12087 0 : new SgOmpExtImplementationDefinedRequirementClause ( SgOmpExtImplementationDefinedRequirementClauseStorageArray[i] ) ;
12088 : }
12089 0 : delete [] SgOmpExtImplementationDefinedRequirementClauseStorageArray;
12090 : }
12091 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpRelaxedClause ) ;
12092 0 : std::cout << " SgOmpRelaxedClause has size " << sizeOfActualPool << std::endl;
12093 0 : if ( 0 < sizeOfActualPool )
12094 : {
12095 0 : SgOmpRelaxedClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12096 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12097 : {
12098 0 : new SgOmpRelaxedClause ( SgOmpRelaxedClauseStorageArray[i] ) ;
12099 : }
12100 0 : delete [] SgOmpRelaxedClauseStorageArray;
12101 : }
12102 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpParallelClause ) ;
12103 0 : std::cout << " SgOmpParallelClause has size " << sizeOfActualPool << std::endl;
12104 0 : if ( 0 < sizeOfActualPool )
12105 : {
12106 0 : SgOmpParallelClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12107 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12108 : {
12109 0 : new SgOmpParallelClause ( SgOmpParallelClauseStorageArray[i] ) ;
12110 : }
12111 0 : delete [] SgOmpParallelClauseStorageArray;
12112 : }
12113 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSectionsClause ) ;
12114 0 : std::cout << " SgOmpSectionsClause has size " << sizeOfActualPool << std::endl;
12115 0 : if ( 0 < sizeOfActualPool )
12116 : {
12117 0 : SgOmpSectionsClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12118 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12119 : {
12120 0 : new SgOmpSectionsClause ( SgOmpSectionsClauseStorageArray[i] ) ;
12121 : }
12122 0 : delete [] SgOmpSectionsClauseStorageArray;
12123 : }
12124 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpForClause ) ;
12125 0 : std::cout << " SgOmpForClause has size " << sizeOfActualPool << std::endl;
12126 0 : if ( 0 < sizeOfActualPool )
12127 : {
12128 0 : SgOmpForClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12129 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12130 : {
12131 0 : new SgOmpForClause ( SgOmpForClauseStorageArray[i] ) ;
12132 : }
12133 0 : delete [] SgOmpForClauseStorageArray;
12134 : }
12135 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskgroupClause ) ;
12136 0 : std::cout << " SgOmpTaskgroupClause has size " << sizeOfActualPool << std::endl;
12137 0 : if ( 0 < sizeOfActualPool )
12138 : {
12139 0 : SgOmpTaskgroupClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12140 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12141 : {
12142 0 : new SgOmpTaskgroupClause ( SgOmpTaskgroupClauseStorageArray[i] ) ;
12143 : }
12144 0 : delete [] SgOmpTaskgroupClauseStorageArray;
12145 : }
12146 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirNumUnitsField ) ;
12147 0 : std::cout << " SgUpirNumUnitsField has size " << sizeOfActualPool << std::endl;
12148 0 : if ( 0 < sizeOfActualPool )
12149 : {
12150 0 : SgUpirNumUnitsFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12151 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12152 : {
12153 0 : new SgUpirNumUnitsField ( SgUpirNumUnitsFieldStorageArray[i] ) ;
12154 : }
12155 0 : delete [] SgUpirNumUnitsFieldStorageArray;
12156 : }
12157 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNumTeamsClause ) ;
12158 0 : std::cout << " SgOmpNumTeamsClause has size " << sizeOfActualPool << std::endl;
12159 0 : if ( 0 < sizeOfActualPool )
12160 : {
12161 0 : SgOmpNumTeamsClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12162 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12163 : {
12164 0 : new SgOmpNumTeamsClause ( SgOmpNumTeamsClauseStorageArray[i] ) ;
12165 : }
12166 0 : delete [] SgOmpNumTeamsClauseStorageArray;
12167 : }
12168 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpGrainsizeClause ) ;
12169 0 : std::cout << " SgOmpGrainsizeClause has size " << sizeOfActualPool << std::endl;
12170 0 : if ( 0 < sizeOfActualPool )
12171 : {
12172 0 : SgOmpGrainsizeClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12173 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12174 : {
12175 0 : new SgOmpGrainsizeClause ( SgOmpGrainsizeClauseStorageArray[i] ) ;
12176 : }
12177 0 : delete [] SgOmpGrainsizeClauseStorageArray;
12178 : }
12179 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDetachClause ) ;
12180 0 : std::cout << " SgOmpDetachClause has size " << sizeOfActualPool << std::endl;
12181 0 : if ( 0 < sizeOfActualPool )
12182 : {
12183 0 : SgOmpDetachClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12184 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12185 : {
12186 0 : new SgOmpDetachClause ( SgOmpDetachClauseStorageArray[i] ) ;
12187 : }
12188 0 : delete [] SgOmpDetachClauseStorageArray;
12189 : }
12190 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNumTasksClause ) ;
12191 0 : std::cout << " SgOmpNumTasksClause has size " << sizeOfActualPool << std::endl;
12192 0 : if ( 0 < sizeOfActualPool )
12193 : {
12194 0 : SgOmpNumTasksClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12195 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12196 : {
12197 0 : new SgOmpNumTasksClause ( SgOmpNumTasksClauseStorageArray[i] ) ;
12198 : }
12199 0 : delete [] SgOmpNumTasksClauseStorageArray;
12200 : }
12201 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNogroupClause ) ;
12202 0 : std::cout << " SgOmpNogroupClause has size " << sizeOfActualPool << std::endl;
12203 0 : if ( 0 < sizeOfActualPool )
12204 : {
12205 0 : SgOmpNogroupClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12206 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12207 : {
12208 0 : new SgOmpNogroupClause ( SgOmpNogroupClauseStorageArray[i] ) ;
12209 : }
12210 0 : delete [] SgOmpNogroupClauseStorageArray;
12211 : }
12212 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpHintClause ) ;
12213 0 : std::cout << " SgOmpHintClause has size " << sizeOfActualPool << std::endl;
12214 0 : if ( 0 < sizeOfActualPool )
12215 : {
12216 0 : SgOmpHintClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12217 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12218 : {
12219 0 : new SgOmpHintClause ( SgOmpHintClauseStorageArray[i] ) ;
12220 : }
12221 0 : delete [] SgOmpHintClauseStorageArray;
12222 : }
12223 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpOrderClause ) ;
12224 0 : std::cout << " SgOmpOrderClause has size " << sizeOfActualPool << std::endl;
12225 0 : if ( 0 < sizeOfActualPool )
12226 : {
12227 0 : SgOmpOrderClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12228 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12229 : {
12230 0 : new SgOmpOrderClause ( SgOmpOrderClauseStorageArray[i] ) ;
12231 : }
12232 0 : delete [] SgOmpOrderClauseStorageArray;
12233 : }
12234 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDistScheduleClause ) ;
12235 0 : std::cout << " SgOmpDistScheduleClause has size " << sizeOfActualPool << std::endl;
12236 0 : if ( 0 < sizeOfActualPool )
12237 : {
12238 0 : SgOmpDistScheduleClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12239 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12240 : {
12241 0 : new SgOmpDistScheduleClause ( SgOmpDistScheduleClauseStorageArray[i] ) ;
12242 : }
12243 0 : delete [] SgOmpDistScheduleClauseStorageArray;
12244 : }
12245 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpBindClause ) ;
12246 0 : std::cout << " SgOmpBindClause has size " << sizeOfActualPool << std::endl;
12247 0 : if ( 0 < sizeOfActualPool )
12248 : {
12249 0 : SgOmpBindClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12250 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12251 : {
12252 0 : new SgOmpBindClause ( SgOmpBindClauseStorageArray[i] ) ;
12253 : }
12254 0 : delete [] SgOmpBindClauseStorageArray;
12255 : }
12256 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNontemporalClause ) ;
12257 0 : std::cout << " SgOmpNontemporalClause has size " << sizeOfActualPool << std::endl;
12258 0 : if ( 0 < sizeOfActualPool )
12259 : {
12260 0 : SgOmpNontemporalClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12261 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12262 : {
12263 0 : new SgOmpNontemporalClause ( SgOmpNontemporalClauseStorageArray[i] ) ;
12264 : }
12265 0 : delete [] SgOmpNontemporalClauseStorageArray;
12266 : }
12267 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpInclusiveClause ) ;
12268 0 : std::cout << " SgOmpInclusiveClause has size " << sizeOfActualPool << std::endl;
12269 0 : if ( 0 < sizeOfActualPool )
12270 : {
12271 0 : SgOmpInclusiveClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12272 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12273 : {
12274 0 : new SgOmpInclusiveClause ( SgOmpInclusiveClauseStorageArray[i] ) ;
12275 : }
12276 0 : delete [] SgOmpInclusiveClauseStorageArray;
12277 : }
12278 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpExclusiveClause ) ;
12279 0 : std::cout << " SgOmpExclusiveClause has size " << sizeOfActualPool << std::endl;
12280 0 : if ( 0 < sizeOfActualPool )
12281 : {
12282 0 : SgOmpExclusiveClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12283 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12284 : {
12285 0 : new SgOmpExclusiveClause ( SgOmpExclusiveClauseStorageArray[i] ) ;
12286 : }
12287 0 : delete [] SgOmpExclusiveClauseStorageArray;
12288 : }
12289 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpIsDevicePtrClause ) ;
12290 0 : std::cout << " SgOmpIsDevicePtrClause has size " << sizeOfActualPool << std::endl;
12291 0 : if ( 0 < sizeOfActualPool )
12292 : {
12293 0 : SgOmpIsDevicePtrClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12294 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12295 : {
12296 0 : new SgOmpIsDevicePtrClause ( SgOmpIsDevicePtrClauseStorageArray[i] ) ;
12297 : }
12298 0 : delete [] SgOmpIsDevicePtrClauseStorageArray;
12299 : }
12300 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUseDevicePtrClause ) ;
12301 0 : std::cout << " SgOmpUseDevicePtrClause has size " << sizeOfActualPool << std::endl;
12302 0 : if ( 0 < sizeOfActualPool )
12303 : {
12304 0 : SgOmpUseDevicePtrClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12305 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12306 : {
12307 0 : new SgOmpUseDevicePtrClause ( SgOmpUseDevicePtrClauseStorageArray[i] ) ;
12308 : }
12309 0 : delete [] SgOmpUseDevicePtrClauseStorageArray;
12310 : }
12311 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUseDeviceAddrClause ) ;
12312 0 : std::cout << " SgOmpUseDeviceAddrClause has size " << sizeOfActualPool << std::endl;
12313 0 : if ( 0 < sizeOfActualPool )
12314 : {
12315 0 : SgOmpUseDeviceAddrClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12316 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12317 : {
12318 0 : new SgOmpUseDeviceAddrClause ( SgOmpUseDeviceAddrClauseStorageArray[i] ) ;
12319 : }
12320 0 : delete [] SgOmpUseDeviceAddrClauseStorageArray;
12321 : }
12322 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpThreadLimitClause ) ;
12323 0 : std::cout << " SgOmpThreadLimitClause has size " << sizeOfActualPool << std::endl;
12324 0 : if ( 0 < sizeOfActualPool )
12325 : {
12326 0 : SgOmpThreadLimitClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12327 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12328 : {
12329 0 : new SgOmpThreadLimitClause ( SgOmpThreadLimitClauseStorageArray[i] ) ;
12330 : }
12331 0 : delete [] SgOmpThreadLimitClauseStorageArray;
12332 : }
12333 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpOrderedClause ) ;
12334 0 : std::cout << " SgOmpOrderedClause has size " << sizeOfActualPool << std::endl;
12335 0 : if ( 0 < sizeOfActualPool )
12336 : {
12337 0 : SgOmpOrderedClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12338 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12339 : {
12340 0 : new SgOmpOrderedClause ( SgOmpOrderedClauseStorageArray[i] ) ;
12341 : }
12342 0 : delete [] SgOmpOrderedClauseStorageArray;
12343 : }
12344 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpPrivateClause ) ;
12345 0 : std::cout << " SgOmpPrivateClause has size " << sizeOfActualPool << std::endl;
12346 0 : if ( 0 < sizeOfActualPool )
12347 : {
12348 0 : SgOmpPrivateClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12349 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12350 : {
12351 0 : new SgOmpPrivateClause ( SgOmpPrivateClauseStorageArray[i] ) ;
12352 : }
12353 0 : delete [] SgOmpPrivateClauseStorageArray;
12354 : }
12355 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpReductionClause ) ;
12356 0 : std::cout << " SgOmpReductionClause has size " << sizeOfActualPool << std::endl;
12357 0 : if ( 0 < sizeOfActualPool )
12358 : {
12359 0 : SgOmpReductionClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12360 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12361 : {
12362 0 : new SgOmpReductionClause ( SgOmpReductionClauseStorageArray[i] ) ;
12363 : }
12364 0 : delete [] SgOmpReductionClauseStorageArray;
12365 : }
12366 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpInReductionClause ) ;
12367 0 : std::cout << " SgOmpInReductionClause has size " << sizeOfActualPool << std::endl;
12368 0 : if ( 0 < sizeOfActualPool )
12369 : {
12370 0 : SgOmpInReductionClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12371 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12372 : {
12373 0 : new SgOmpInReductionClause ( SgOmpInReductionClauseStorageArray[i] ) ;
12374 : }
12375 0 : delete [] SgOmpInReductionClauseStorageArray;
12376 : }
12377 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpTaskReductionClause ) ;
12378 0 : std::cout << " SgOmpTaskReductionClause has size " << sizeOfActualPool << std::endl;
12379 0 : if ( 0 < sizeOfActualPool )
12380 : {
12381 0 : SgOmpTaskReductionClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12382 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12383 : {
12384 0 : new SgOmpTaskReductionClause ( SgOmpTaskReductionClauseStorageArray[i] ) ;
12385 : }
12386 0 : delete [] SgOmpTaskReductionClauseStorageArray;
12387 : }
12388 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDefaultmapClause ) ;
12389 0 : std::cout << " SgOmpDefaultmapClause has size " << sizeOfActualPool << std::endl;
12390 0 : if ( 0 < sizeOfActualPool )
12391 : {
12392 0 : SgOmpDefaultmapClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12393 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12394 : {
12395 0 : new SgOmpDefaultmapClause ( SgOmpDefaultmapClauseStorageArray[i] ) ;
12396 : }
12397 0 : delete [] SgOmpDefaultmapClauseStorageArray;
12398 : }
12399 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpScheduleClause ) ;
12400 0 : std::cout << " SgOmpScheduleClause has size " << sizeOfActualPool << std::endl;
12401 0 : if ( 0 < sizeOfActualPool )
12402 : {
12403 0 : SgOmpScheduleClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12404 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12405 : {
12406 0 : new SgOmpScheduleClause ( SgOmpScheduleClauseStorageArray[i] ) ;
12407 : }
12408 0 : delete [] SgOmpScheduleClauseStorageArray;
12409 : }
12410 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSharedClause ) ;
12411 0 : std::cout << " SgOmpSharedClause has size " << sizeOfActualPool << std::endl;
12412 0 : if ( 0 < sizeOfActualPool )
12413 : {
12414 0 : SgOmpSharedClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12415 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12416 : {
12417 0 : new SgOmpSharedClause ( SgOmpSharedClauseStorageArray[i] ) ;
12418 : }
12419 0 : delete [] SgOmpSharedClauseStorageArray;
12420 : }
12421 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUntiedClause ) ;
12422 0 : std::cout << " SgOmpUntiedClause has size " << sizeOfActualPool << std::endl;
12423 0 : if ( 0 < sizeOfActualPool )
12424 : {
12425 0 : SgOmpUntiedClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12426 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12427 : {
12428 0 : new SgOmpUntiedClause ( SgOmpUntiedClauseStorageArray[i] ) ;
12429 : }
12430 0 : delete [] SgOmpUntiedClauseStorageArray;
12431 : }
12432 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMergeableClause ) ;
12433 0 : std::cout << " SgOmpMergeableClause has size " << sizeOfActualPool << std::endl;
12434 0 : if ( 0 < sizeOfActualPool )
12435 : {
12436 0 : SgOmpMergeableClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12437 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12438 : {
12439 0 : new SgOmpMergeableClause ( SgOmpMergeableClauseStorageArray[i] ) ;
12440 : }
12441 0 : delete [] SgOmpMergeableClauseStorageArray;
12442 : }
12443 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpVariablesClause ) ;
12444 0 : std::cout << " SgOmpVariablesClause has size " << sizeOfActualPool << std::endl;
12445 0 : if ( 0 < sizeOfActualPool )
12446 : {
12447 0 : SgOmpVariablesClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12448 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12449 : {
12450 0 : new SgOmpVariablesClause ( SgOmpVariablesClauseStorageArray[i] ) ;
12451 : }
12452 0 : delete [] SgOmpVariablesClauseStorageArray;
12453 : }
12454 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpMapClause ) ;
12455 0 : std::cout << " SgOmpMapClause has size " << sizeOfActualPool << std::endl;
12456 0 : if ( 0 < sizeOfActualPool )
12457 : {
12458 0 : SgOmpMapClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12459 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12460 : {
12461 0 : new SgOmpMapClause ( SgOmpMapClauseStorageArray[i] ) ;
12462 : }
12463 0 : delete [] SgOmpMapClauseStorageArray;
12464 : }
12465 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSafelenClause ) ;
12466 0 : std::cout << " SgOmpSafelenClause has size " << sizeOfActualPool << std::endl;
12467 0 : if ( 0 < sizeOfActualPool )
12468 : {
12469 0 : SgOmpSafelenClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12470 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12471 : {
12472 0 : new SgOmpSafelenClause ( SgOmpSafelenClauseStorageArray[i] ) ;
12473 : }
12474 0 : delete [] SgOmpSafelenClauseStorageArray;
12475 : }
12476 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSimdlenClause ) ;
12477 0 : std::cout << " SgOmpSimdlenClause has size " << sizeOfActualPool << std::endl;
12478 0 : if ( 0 < sizeOfActualPool )
12479 : {
12480 0 : SgOmpSimdlenClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12481 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12482 : {
12483 0 : new SgOmpSimdlenClause ( SgOmpSimdlenClauseStorageArray[i] ) ;
12484 : }
12485 0 : delete [] SgOmpSimdlenClauseStorageArray;
12486 : }
12487 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpLinearClause ) ;
12488 0 : std::cout << " SgOmpLinearClause has size " << sizeOfActualPool << std::endl;
12489 0 : if ( 0 < sizeOfActualPool )
12490 : {
12491 0 : SgOmpLinearClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12492 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12493 : {
12494 0 : new SgOmpLinearClause ( SgOmpLinearClauseStorageArray[i] ) ;
12495 : }
12496 0 : delete [] SgOmpLinearClauseStorageArray;
12497 : }
12498 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpUniformClause ) ;
12499 0 : std::cout << " SgOmpUniformClause has size " << sizeOfActualPool << std::endl;
12500 0 : if ( 0 < sizeOfActualPool )
12501 : {
12502 0 : SgOmpUniformClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12503 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12504 : {
12505 0 : new SgOmpUniformClause ( SgOmpUniformClauseStorageArray[i] ) ;
12506 : }
12507 0 : delete [] SgOmpUniformClauseStorageArray;
12508 : }
12509 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAlignedClause ) ;
12510 0 : std::cout << " SgOmpAlignedClause has size " << sizeOfActualPool << std::endl;
12511 0 : if ( 0 < sizeOfActualPool )
12512 : {
12513 0 : SgOmpAlignedClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12514 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12515 : {
12516 0 : new SgOmpAlignedClause ( SgOmpAlignedClauseStorageArray[i] ) ;
12517 : }
12518 0 : delete [] SgOmpAlignedClauseStorageArray;
12519 : }
12520 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpProcBindClause ) ;
12521 0 : std::cout << " SgOmpProcBindClause has size " << sizeOfActualPool << std::endl;
12522 0 : if ( 0 < sizeOfActualPool )
12523 : {
12524 0 : SgOmpProcBindClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12525 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12526 : {
12527 0 : new SgOmpProcBindClause ( SgOmpProcBindClauseStorageArray[i] ) ;
12528 : }
12529 0 : delete [] SgOmpProcBindClauseStorageArray;
12530 : }
12531 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAtomicClause ) ;
12532 0 : std::cout << " SgOmpAtomicClause has size " << sizeOfActualPool << std::endl;
12533 0 : if ( 0 < sizeOfActualPool )
12534 : {
12535 0 : SgOmpAtomicClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12536 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12537 : {
12538 0 : new SgOmpAtomicClause ( SgOmpAtomicClauseStorageArray[i] ) ;
12539 : }
12540 0 : delete [] SgOmpAtomicClauseStorageArray;
12541 : }
12542 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpInbranchClause ) ;
12543 0 : std::cout << " SgOmpInbranchClause has size " << sizeOfActualPool << std::endl;
12544 0 : if ( 0 < sizeOfActualPool )
12545 : {
12546 0 : SgOmpInbranchClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12547 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12548 : {
12549 0 : new SgOmpInbranchClause ( SgOmpInbranchClauseStorageArray[i] ) ;
12550 : }
12551 0 : delete [] SgOmpInbranchClauseStorageArray;
12552 : }
12553 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpNotinbranchClause ) ;
12554 0 : std::cout << " SgOmpNotinbranchClause has size " << sizeOfActualPool << std::endl;
12555 0 : if ( 0 < sizeOfActualPool )
12556 : {
12557 0 : SgOmpNotinbranchClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12558 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12559 : {
12560 0 : new SgOmpNotinbranchClause ( SgOmpNotinbranchClauseStorageArray[i] ) ;
12561 : }
12562 0 : delete [] SgOmpNotinbranchClauseStorageArray;
12563 : }
12564 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpDependClause ) ;
12565 0 : std::cout << " SgOmpDependClause has size " << sizeOfActualPool << std::endl;
12566 0 : if ( 0 < sizeOfActualPool )
12567 : {
12568 0 : SgOmpDependClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12569 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12570 : {
12571 0 : new SgOmpDependClause ( SgOmpDependClauseStorageArray[i] ) ;
12572 : }
12573 0 : delete [] SgOmpDependClauseStorageArray;
12574 : }
12575 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpAffinityClause ) ;
12576 0 : std::cout << " SgOmpAffinityClause has size " << sizeOfActualPool << std::endl;
12577 0 : if ( 0 < sizeOfActualPool )
12578 : {
12579 0 : SgOmpAffinityClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12580 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12581 : {
12582 0 : new SgOmpAffinityClause ( SgOmpAffinityClauseStorageArray[i] ) ;
12583 : }
12584 0 : delete [] SgOmpAffinityClauseStorageArray;
12585 : }
12586 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpWhenClause ) ;
12587 0 : std::cout << " SgOmpWhenClause has size " << sizeOfActualPool << std::endl;
12588 0 : if ( 0 < sizeOfActualPool )
12589 : {
12590 0 : SgOmpWhenClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12591 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12592 : {
12593 0 : new SgOmpWhenClause ( SgOmpWhenClauseStorageArray[i] ) ;
12594 : }
12595 0 : delete [] SgOmpWhenClauseStorageArray;
12596 : }
12597 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpFullClause ) ;
12598 0 : std::cout << " SgOmpFullClause has size " << sizeOfActualPool << std::endl;
12599 0 : if ( 0 < sizeOfActualPool )
12600 : {
12601 0 : SgOmpFullClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12602 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12603 : {
12604 0 : new SgOmpFullClause ( SgOmpFullClauseStorageArray[i] ) ;
12605 : }
12606 0 : delete [] SgOmpFullClauseStorageArray;
12607 : }
12608 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpPartialClause ) ;
12609 0 : std::cout << " SgOmpPartialClause has size " << sizeOfActualPool << std::endl;
12610 0 : if ( 0 < sizeOfActualPool )
12611 : {
12612 0 : SgOmpPartialClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12613 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12614 : {
12615 0 : new SgOmpPartialClause ( SgOmpPartialClauseStorageArray[i] ) ;
12616 : }
12617 0 : delete [] SgOmpPartialClauseStorageArray;
12618 : }
12619 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOmpSizesClause ) ;
12620 0 : std::cout << " SgOmpSizesClause has size " << sizeOfActualPool << std::endl;
12621 0 : if ( 0 < sizeOfActualPool )
12622 : {
12623 0 : SgOmpSizesClauseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12624 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12625 : {
12626 0 : new SgOmpSizesClause ( SgOmpSizesClauseStorageArray[i] ) ;
12627 : }
12628 0 : delete [] SgOmpSizesClauseStorageArray;
12629 : }
12630 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirBranchField ) ;
12631 0 : std::cout << " SgUpirBranchField has size " << sizeOfActualPool << std::endl;
12632 0 : if ( 0 < sizeOfActualPool )
12633 : {
12634 0 : SgUpirBranchFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12635 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12636 : {
12637 0 : new SgUpirBranchField ( SgUpirBranchFieldStorageArray[i] ) ;
12638 : }
12639 0 : delete [] SgUpirBranchFieldStorageArray;
12640 : }
12641 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirNestedLevelField ) ;
12642 0 : std::cout << " SgUpirNestedLevelField has size " << sizeOfActualPool << std::endl;
12643 0 : if ( 0 < sizeOfActualPool )
12644 : {
12645 0 : SgUpirNestedLevelFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12646 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12647 : {
12648 0 : new SgUpirNestedLevelField ( SgUpirNestedLevelFieldStorageArray[i] ) ;
12649 : }
12650 0 : delete [] SgUpirNestedLevelFieldStorageArray;
12651 : }
12652 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirNestedParentField ) ;
12653 0 : std::cout << " SgUpirNestedParentField has size " << sizeOfActualPool << std::endl;
12654 0 : if ( 0 < sizeOfActualPool )
12655 : {
12656 0 : SgUpirNestedParentFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12657 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12658 : {
12659 0 : new SgUpirNestedParentField ( SgUpirNestedParentFieldStorageArray[i] ) ;
12660 : }
12661 0 : delete [] SgUpirNestedParentFieldStorageArray;
12662 : }
12663 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirNestedChildField ) ;
12664 0 : std::cout << " SgUpirNestedChildField has size " << sizeOfActualPool << std::endl;
12665 0 : if ( 0 < sizeOfActualPool )
12666 : {
12667 0 : SgUpirNestedChildFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12668 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12669 : {
12670 0 : new SgUpirNestedChildField ( SgUpirNestedChildFieldStorageArray[i] ) ;
12671 : }
12672 0 : delete [] SgUpirNestedChildFieldStorageArray;
12673 : }
12674 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirSyncField ) ;
12675 0 : std::cout << " SgUpirSyncField has size " << sizeOfActualPool << std::endl;
12676 0 : if ( 0 < sizeOfActualPool )
12677 : {
12678 0 : SgUpirSyncFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12679 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12680 : {
12681 0 : new SgUpirSyncField ( SgUpirSyncFieldStorageArray[i] ) ;
12682 : }
12683 0 : delete [] SgUpirSyncFieldStorageArray;
12684 : }
12685 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirDataField ) ;
12686 0 : std::cout << " SgUpirDataField has size " << sizeOfActualPool << std::endl;
12687 0 : if ( 0 < sizeOfActualPool )
12688 : {
12689 0 : SgUpirDataFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12690 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12691 : {
12692 0 : new SgUpirDataField ( SgUpirDataFieldStorageArray[i] ) ;
12693 : }
12694 0 : delete [] SgUpirDataFieldStorageArray;
12695 : }
12696 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirDataItemField ) ;
12697 0 : std::cout << " SgUpirDataItemField has size " << sizeOfActualPool << std::endl;
12698 0 : if ( 0 < sizeOfActualPool )
12699 : {
12700 0 : SgUpirDataItemFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12701 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12702 : {
12703 0 : new SgUpirDataItemField ( SgUpirDataItemFieldStorageArray[i] ) ;
12704 : }
12705 0 : delete [] SgUpirDataItemFieldStorageArray;
12706 : }
12707 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpirTargetField ) ;
12708 0 : std::cout << " SgUpirTargetField has size " << sizeOfActualPool << std::endl;
12709 0 : if ( 0 < sizeOfActualPool )
12710 : {
12711 0 : SgUpirTargetFieldStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12712 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12713 : {
12714 0 : new SgUpirTargetField ( SgUpirTargetFieldStorageArray[i] ) ;
12715 : }
12716 0 : delete [] SgUpirTargetFieldStorageArray;
12717 : }
12718 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOpenclAccessModeModifier ) ;
12719 0 : std::cout << " SgOpenclAccessModeModifier has size " << sizeOfActualPool << std::endl;
12720 0 : if ( 0 < sizeOfActualPool )
12721 : {
12722 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12723 : {
12724 0 : new SgOpenclAccessModeModifier ( SgOpenclAccessModeModifierStorageArray[i] ) ;
12725 : }
12726 0 : delete [] SgOpenclAccessModeModifierStorageArray;
12727 : }
12728 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOpenStatement ) ;
12729 0 : std::cout << " SgOpenStatement has size " << sizeOfActualPool << std::endl;
12730 0 : if ( 0 < sizeOfActualPool )
12731 : {
12732 0 : SgOpenStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12733 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12734 : {
12735 0 : new SgOpenStatement ( SgOpenStatementStorageArray[i] ) ;
12736 : }
12737 0 : delete [] SgOpenStatementStorageArray;
12738 : }
12739 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOptions ) ;
12740 0 : std::cout << " SgOptions has size " << sizeOfActualPool << std::endl;
12741 0 : if ( 0 < sizeOfActualPool )
12742 : {
12743 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12744 : {
12745 0 : new SgOptions ( SgOptionsStorageArray[i] ) ;
12746 : }
12747 0 : delete [] SgOptionsStorageArray;
12748 : }
12749 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgOrOp ) ;
12750 0 : std::cout << " SgOrOp has size " << sizeOfActualPool << std::endl;
12751 0 : if ( 0 < sizeOfActualPool )
12752 : {
12753 0 : SgOrOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12754 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12755 : {
12756 0 : new SgOrOp ( SgOrOpStorageArray[i] ) ;
12757 : }
12758 0 : delete [] SgOrOpStorageArray;
12759 : }
12760 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgParameterStatement ) ;
12761 0 : std::cout << " SgParameterStatement has size " << sizeOfActualPool << std::endl;
12762 0 : if ( 0 < sizeOfActualPool )
12763 : {
12764 0 : SgParameterStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12765 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12766 : {
12767 0 : new SgParameterStatement ( SgParameterStatementStorageArray[i] ) ;
12768 : }
12769 0 : delete [] SgParameterStatementStorageArray;
12770 : }
12771 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPartialFunctionModifierType ) ;
12772 0 : std::cout << " SgPartialFunctionModifierType has size " << sizeOfActualPool << std::endl;
12773 0 : if ( 0 < sizeOfActualPool )
12774 : {
12775 0 : SgPartialFunctionModifierTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12776 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12777 : {
12778 0 : new SgPartialFunctionModifierType ( SgPartialFunctionModifierTypeStorageArray[i] ) ;
12779 : }
12780 0 : delete [] SgPartialFunctionModifierTypeStorageArray;
12781 : }
12782 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPartialFunctionType ) ;
12783 0 : std::cout << " SgPartialFunctionType has size " << sizeOfActualPool << std::endl;
12784 0 : if ( 0 < sizeOfActualPool )
12785 : {
12786 0 : SgPartialFunctionTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12787 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12788 : {
12789 0 : new SgPartialFunctionType ( SgPartialFunctionTypeStorageArray[i] ) ;
12790 : }
12791 0 : delete [] SgPartialFunctionTypeStorageArray;
12792 : }
12793 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPassStatement ) ;
12794 0 : std::cout << " SgPassStatement has size " << sizeOfActualPool << std::endl;
12795 0 : if ( 0 < sizeOfActualPool )
12796 : {
12797 0 : SgPassStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12798 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12799 : {
12800 0 : new SgPassStatement ( SgPassStatementStorageArray[i] ) ;
12801 : }
12802 0 : delete [] SgPassStatementStorageArray;
12803 : }
12804 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPlusAssignOp ) ;
12805 0 : std::cout << " SgPlusAssignOp has size " << sizeOfActualPool << std::endl;
12806 0 : if ( 0 < sizeOfActualPool )
12807 : {
12808 0 : SgPlusAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12809 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12810 : {
12811 0 : new SgPlusAssignOp ( SgPlusAssignOpStorageArray[i] ) ;
12812 : }
12813 0 : delete [] SgPlusAssignOpStorageArray;
12814 : }
12815 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPlusPlusOp ) ;
12816 0 : std::cout << " SgPlusPlusOp has size " << sizeOfActualPool << std::endl;
12817 0 : if ( 0 < sizeOfActualPool )
12818 : {
12819 0 : SgPlusPlusOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12820 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12821 : {
12822 0 : new SgPlusPlusOp ( SgPlusPlusOpStorageArray[i] ) ;
12823 : }
12824 0 : delete [] SgPlusPlusOpStorageArray;
12825 : }
12826 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPntrArrRefExp ) ;
12827 0 : std::cout << " SgPntrArrRefExp has size " << sizeOfActualPool << std::endl;
12828 0 : if ( 0 < sizeOfActualPool )
12829 : {
12830 0 : SgPntrArrRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12831 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12832 : {
12833 0 : new SgPntrArrRefExp ( SgPntrArrRefExpStorageArray[i] ) ;
12834 : }
12835 0 : delete [] SgPntrArrRefExpStorageArray;
12836 : }
12837 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPointerAssignOp ) ;
12838 0 : std::cout << " SgPointerAssignOp has size " << sizeOfActualPool << std::endl;
12839 0 : if ( 0 < sizeOfActualPool )
12840 : {
12841 0 : SgPointerAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12842 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12843 : {
12844 0 : new SgPointerAssignOp ( SgPointerAssignOpStorageArray[i] ) ;
12845 : }
12846 0 : delete [] SgPointerAssignOpStorageArray;
12847 : }
12848 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPointerDerefExp ) ;
12849 0 : std::cout << " SgPointerDerefExp has size " << sizeOfActualPool << std::endl;
12850 0 : if ( 0 < sizeOfActualPool )
12851 : {
12852 0 : SgPointerDerefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12853 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12854 : {
12855 0 : new SgPointerDerefExp ( SgPointerDerefExpStorageArray[i] ) ;
12856 : }
12857 0 : delete [] SgPointerDerefExpStorageArray;
12858 : }
12859 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPointerMemberType ) ;
12860 0 : std::cout << " SgPointerMemberType has size " << sizeOfActualPool << std::endl;
12861 0 : if ( 0 < sizeOfActualPool )
12862 : {
12863 0 : SgPointerMemberTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12864 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12865 : {
12866 0 : new SgPointerMemberType ( SgPointerMemberTypeStorageArray[i] ) ;
12867 : }
12868 0 : delete [] SgPointerMemberTypeStorageArray;
12869 : }
12870 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPointerType ) ;
12871 0 : std::cout << " SgPointerType has size " << sizeOfActualPool << std::endl;
12872 0 : if ( 0 < sizeOfActualPool )
12873 : {
12874 0 : SgPointerTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12875 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12876 : {
12877 0 : new SgPointerType ( SgPointerTypeStorageArray[i] ) ;
12878 : }
12879 0 : delete [] SgPointerTypeStorageArray;
12880 : }
12881 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPowerOp ) ;
12882 0 : std::cout << " SgPowerOp has size " << sizeOfActualPool << std::endl;
12883 0 : if ( 0 < sizeOfActualPool )
12884 : {
12885 0 : SgPowerOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12886 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12887 : {
12888 0 : new SgPowerOp ( SgPowerOpStorageArray[i] ) ;
12889 : }
12890 0 : delete [] SgPowerOpStorageArray;
12891 : }
12892 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPragma ) ;
12893 0 : std::cout << " SgPragma has size " << sizeOfActualPool << std::endl;
12894 0 : if ( 0 < sizeOfActualPool )
12895 : {
12896 0 : SgPragmaStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12897 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12898 : {
12899 0 : new SgPragma ( SgPragmaStorageArray[i] ) ;
12900 : }
12901 0 : delete [] SgPragmaStorageArray;
12902 : }
12903 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPragmaDeclaration ) ;
12904 0 : std::cout << " SgPragmaDeclaration has size " << sizeOfActualPool << std::endl;
12905 0 : if ( 0 < sizeOfActualPool )
12906 : {
12907 0 : SgPragmaDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12908 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12909 : {
12910 0 : new SgPragmaDeclaration ( SgPragmaDeclarationStorageArray[i] ) ;
12911 : }
12912 0 : delete [] SgPragmaDeclarationStorageArray;
12913 : }
12914 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPrintStatement ) ;
12915 0 : std::cout << " SgPrintStatement has size " << sizeOfActualPool << std::endl;
12916 0 : if ( 0 < sizeOfActualPool )
12917 : {
12918 0 : SgPrintStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12919 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12920 : {
12921 0 : new SgPrintStatement ( SgPrintStatementStorageArray[i] ) ;
12922 : }
12923 0 : delete [] SgPrintStatementStorageArray;
12924 : }
12925 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgProcedureHeaderStatement ) ;
12926 0 : std::cout << " SgProcedureHeaderStatement has size " << sizeOfActualPool << std::endl;
12927 0 : if ( 0 < sizeOfActualPool )
12928 : {
12929 0 : SgProcedureHeaderStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12930 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12931 : {
12932 0 : new SgProcedureHeaderStatement ( SgProcedureHeaderStatementStorageArray[i] ) ;
12933 : }
12934 0 : delete [] SgProcedureHeaderStatementStorageArray;
12935 : }
12936 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgProgramHeaderStatement ) ;
12937 0 : std::cout << " SgProgramHeaderStatement has size " << sizeOfActualPool << std::endl;
12938 0 : if ( 0 < sizeOfActualPool )
12939 : {
12940 0 : SgProgramHeaderStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12941 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12942 : {
12943 0 : new SgProgramHeaderStatement ( SgProgramHeaderStatementStorageArray[i] ) ;
12944 : }
12945 0 : delete [] SgProgramHeaderStatementStorageArray;
12946 : }
12947 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgProject ) ;
12948 0 : std::cout << " SgProject has size " << sizeOfActualPool << std::endl;
12949 0 : if ( 0 < sizeOfActualPool )
12950 : {
12951 0 : SgProjectStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12952 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12953 : {
12954 0 : new SgProject ( SgProjectStorageArray[i] ) ;
12955 : }
12956 0 : delete [] SgProjectStorageArray;
12957 : }
12958 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgPseudoDestructorRefExp ) ;
12959 0 : std::cout << " SgPseudoDestructorRefExp has size " << sizeOfActualPool << std::endl;
12960 0 : if ( 0 < sizeOfActualPool )
12961 : {
12962 0 : SgPseudoDestructorRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12963 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12964 : {
12965 0 : new SgPseudoDestructorRefExp ( SgPseudoDestructorRefExpStorageArray[i] ) ;
12966 : }
12967 0 : delete [] SgPseudoDestructorRefExpStorageArray;
12968 : }
12969 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgQualifiedName ) ;
12970 0 : std::cout << " SgQualifiedName has size " << sizeOfActualPool << std::endl;
12971 0 : if ( 0 < sizeOfActualPool )
12972 : {
12973 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12974 : {
12975 0 : new SgQualifiedName ( SgQualifiedNameStorageArray[i] ) ;
12976 : }
12977 0 : delete [] SgQualifiedNameStorageArray;
12978 : }
12979 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgQualifiedNameType ) ;
12980 0 : std::cout << " SgQualifiedNameType has size " << sizeOfActualPool << std::endl;
12981 0 : if ( 0 < sizeOfActualPool )
12982 : {
12983 0 : SgQualifiedNameTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12984 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12985 : {
12986 0 : new SgQualifiedNameType ( SgQualifiedNameTypeStorageArray[i] ) ;
12987 : }
12988 0 : delete [] SgQualifiedNameTypeStorageArray;
12989 : }
12990 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRangeExp ) ;
12991 0 : std::cout << " SgRangeExp has size " << sizeOfActualPool << std::endl;
12992 0 : if ( 0 < sizeOfActualPool )
12993 : {
12994 0 : SgRangeExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
12995 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
12996 : {
12997 0 : new SgRangeExp ( SgRangeExpStorageArray[i] ) ;
12998 : }
12999 0 : delete [] SgRangeExpStorageArray;
13000 : }
13001 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRangeBasedForStatement ) ;
13002 0 : std::cout << " SgRangeBasedForStatement has size " << sizeOfActualPool << std::endl;
13003 0 : if ( 0 < sizeOfActualPool )
13004 : {
13005 0 : SgRangeBasedForStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13006 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13007 : {
13008 0 : new SgRangeBasedForStatement ( SgRangeBasedForStatementStorageArray[i] ) ;
13009 : }
13010 0 : delete [] SgRangeBasedForStatementStorageArray;
13011 : }
13012 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgReadStatement ) ;
13013 0 : std::cout << " SgReadStatement has size " << sizeOfActualPool << std::endl;
13014 0 : if ( 0 < sizeOfActualPool )
13015 : {
13016 0 : SgReadStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13017 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13018 : {
13019 0 : new SgReadStatement ( SgReadStatementStorageArray[i] ) ;
13020 : }
13021 0 : delete [] SgReadStatementStorageArray;
13022 : }
13023 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRealPartOp ) ;
13024 0 : std::cout << " SgRealPartOp has size " << sizeOfActualPool << std::endl;
13025 0 : if ( 0 < sizeOfActualPool )
13026 : {
13027 0 : SgRealPartOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13028 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13029 : {
13030 0 : new SgRealPartOp ( SgRealPartOpStorageArray[i] ) ;
13031 : }
13032 0 : delete [] SgRealPartOpStorageArray;
13033 : }
13034 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRefExp ) ;
13035 0 : std::cout << " SgRefExp has size " << sizeOfActualPool << std::endl;
13036 0 : if ( 0 < sizeOfActualPool )
13037 : {
13038 0 : SgRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13039 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13040 : {
13041 0 : new SgRefExp ( SgRefExpStorageArray[i] ) ;
13042 : }
13043 0 : delete [] SgRefExpStorageArray;
13044 : }
13045 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgReferenceType ) ;
13046 0 : std::cout << " SgReferenceType has size " << sizeOfActualPool << std::endl;
13047 0 : if ( 0 < sizeOfActualPool )
13048 : {
13049 0 : SgReferenceTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13050 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13051 : {
13052 0 : new SgReferenceType ( SgReferenceTypeStorageArray[i] ) ;
13053 : }
13054 0 : delete [] SgReferenceTypeStorageArray;
13055 : }
13056 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRenamePair ) ;
13057 0 : std::cout << " SgRenamePair has size " << sizeOfActualPool << std::endl;
13058 0 : if ( 0 < sizeOfActualPool )
13059 : {
13060 0 : SgRenamePairStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13061 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13062 : {
13063 0 : new SgRenamePair ( SgRenamePairStorageArray[i] ) ;
13064 : }
13065 0 : delete [] SgRenamePairStorageArray;
13066 : }
13067 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRenameSymbol ) ;
13068 0 : std::cout << " SgRenameSymbol has size " << sizeOfActualPool << std::endl;
13069 0 : if ( 0 < sizeOfActualPool )
13070 : {
13071 0 : SgRenameSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13072 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13073 : {
13074 0 : new SgRenameSymbol ( SgRenameSymbolStorageArray[i] ) ;
13075 : }
13076 0 : delete [] SgRenameSymbolStorageArray;
13077 : }
13078 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgReturnStmt ) ;
13079 0 : std::cout << " SgReturnStmt has size " << sizeOfActualPool << std::endl;
13080 0 : if ( 0 < sizeOfActualPool )
13081 : {
13082 0 : SgReturnStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13083 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13084 : {
13085 0 : new SgReturnStmt ( SgReturnStmtStorageArray[i] ) ;
13086 : }
13087 0 : delete [] SgReturnStmtStorageArray;
13088 : }
13089 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRewindStatement ) ;
13090 0 : std::cout << " SgRewindStatement has size " << sizeOfActualPool << std::endl;
13091 0 : if ( 0 < sizeOfActualPool )
13092 : {
13093 0 : SgRewindStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13094 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13095 : {
13096 0 : new SgRewindStatement ( SgRewindStatementStorageArray[i] ) ;
13097 : }
13098 0 : delete [] SgRewindStatementStorageArray;
13099 : }
13100 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRshiftAssignOp ) ;
13101 0 : std::cout << " SgRshiftAssignOp has size " << sizeOfActualPool << std::endl;
13102 0 : if ( 0 < sizeOfActualPool )
13103 : {
13104 0 : SgRshiftAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13105 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13106 : {
13107 0 : new SgRshiftAssignOp ( SgRshiftAssignOpStorageArray[i] ) ;
13108 : }
13109 0 : delete [] SgRshiftAssignOpStorageArray;
13110 : }
13111 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRshiftOp ) ;
13112 0 : std::cout << " SgRshiftOp has size " << sizeOfActualPool << std::endl;
13113 0 : if ( 0 < sizeOfActualPool )
13114 : {
13115 0 : SgRshiftOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13116 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13117 : {
13118 0 : new SgRshiftOp ( SgRshiftOpStorageArray[i] ) ;
13119 : }
13120 0 : delete [] SgRshiftOpStorageArray;
13121 : }
13122 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgRvalueReferenceType ) ;
13123 0 : std::cout << " SgRvalueReferenceType has size " << sizeOfActualPool << std::endl;
13124 0 : if ( 0 < sizeOfActualPool )
13125 : {
13126 0 : SgRvalueReferenceTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13127 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13128 : {
13129 0 : new SgRvalueReferenceType ( SgRvalueReferenceTypeStorageArray[i] ) ;
13130 : }
13131 0 : delete [] SgRvalueReferenceTypeStorageArray;
13132 : }
13133 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgScopeOp ) ;
13134 0 : std::cout << " SgScopeOp has size " << sizeOfActualPool << std::endl;
13135 0 : if ( 0 < sizeOfActualPool )
13136 : {
13137 0 : SgScopeOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13138 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13139 : {
13140 0 : new SgScopeOp ( SgScopeOpStorageArray[i] ) ;
13141 : }
13142 0 : delete [] SgScopeOpStorageArray;
13143 : }
13144 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgScopeStatement ) ;
13145 0 : std::cout << " SgScopeStatement has size " << sizeOfActualPool << std::endl;
13146 0 : if ( 0 < sizeOfActualPool )
13147 : {
13148 0 : SgScopeStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13149 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13150 : {
13151 0 : new SgScopeStatement ( SgScopeStatementStorageArray[i] ) ;
13152 : }
13153 0 : delete [] SgScopeStatementStorageArray;
13154 : }
13155 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSequenceStatement ) ;
13156 0 : std::cout << " SgSequenceStatement has size " << sizeOfActualPool << std::endl;
13157 0 : if ( 0 < sizeOfActualPool )
13158 : {
13159 0 : SgSequenceStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13160 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13161 : {
13162 0 : new SgSequenceStatement ( SgSequenceStatementStorageArray[i] ) ;
13163 : }
13164 0 : delete [] SgSequenceStatementStorageArray;
13165 : }
13166 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSetComprehension ) ;
13167 0 : std::cout << " SgSetComprehension has size " << sizeOfActualPool << std::endl;
13168 0 : if ( 0 < sizeOfActualPool )
13169 : {
13170 0 : SgSetComprehensionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13171 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13172 : {
13173 0 : new SgSetComprehension ( SgSetComprehensionStorageArray[i] ) ;
13174 : }
13175 0 : delete [] SgSetComprehensionStorageArray;
13176 : }
13177 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgShortVal ) ;
13178 0 : std::cout << " SgShortVal has size " << sizeOfActualPool << std::endl;
13179 0 : if ( 0 < sizeOfActualPool )
13180 : {
13181 0 : SgShortValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13182 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13183 : {
13184 0 : new SgShortVal ( SgShortValStorageArray[i] ) ;
13185 : }
13186 0 : delete [] SgShortValStorageArray;
13187 : }
13188 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDBinaryOp ) ;
13189 0 : std::cout << " SgSIMDBinaryOp has size " << sizeOfActualPool << std::endl;
13190 0 : if ( 0 < sizeOfActualPool )
13191 : {
13192 0 : SgSIMDBinaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13193 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13194 : {
13195 0 : new SgSIMDBinaryOp ( SgSIMDBinaryOpStorageArray[i] ) ;
13196 : }
13197 0 : delete [] SgSIMDBinaryOpStorageArray;
13198 : }
13199 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDAddOp ) ;
13200 0 : std::cout << " SgSIMDAddOp has size " << sizeOfActualPool << std::endl;
13201 0 : if ( 0 < sizeOfActualPool )
13202 : {
13203 0 : SgSIMDAddOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13204 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13205 : {
13206 0 : new SgSIMDAddOp ( SgSIMDAddOpStorageArray[i] ) ;
13207 : }
13208 0 : delete [] SgSIMDAddOpStorageArray;
13209 : }
13210 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDSubOp ) ;
13211 0 : std::cout << " SgSIMDSubOp has size " << sizeOfActualPool << std::endl;
13212 0 : if ( 0 < sizeOfActualPool )
13213 : {
13214 0 : SgSIMDSubOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13215 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13216 : {
13217 0 : new SgSIMDSubOp ( SgSIMDSubOpStorageArray[i] ) ;
13218 : }
13219 0 : delete [] SgSIMDSubOpStorageArray;
13220 : }
13221 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDMulOp ) ;
13222 0 : std::cout << " SgSIMDMulOp has size " << sizeOfActualPool << std::endl;
13223 0 : if ( 0 < sizeOfActualPool )
13224 : {
13225 0 : SgSIMDMulOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13226 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13227 : {
13228 0 : new SgSIMDMulOp ( SgSIMDMulOpStorageArray[i] ) ;
13229 : }
13230 0 : delete [] SgSIMDMulOpStorageArray;
13231 : }
13232 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDDivOp ) ;
13233 0 : std::cout << " SgSIMDDivOp has size " << sizeOfActualPool << std::endl;
13234 0 : if ( 0 < sizeOfActualPool )
13235 : {
13236 0 : SgSIMDDivOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13237 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13238 : {
13239 0 : new SgSIMDDivOp ( SgSIMDDivOpStorageArray[i] ) ;
13240 : }
13241 0 : delete [] SgSIMDDivOpStorageArray;
13242 : }
13243 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDFmaOp ) ;
13244 0 : std::cout << " SgSIMDFmaOp has size " << sizeOfActualPool << std::endl;
13245 0 : if ( 0 < sizeOfActualPool )
13246 : {
13247 0 : SgSIMDFmaOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13248 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13249 : {
13250 0 : new SgSIMDFmaOp ( SgSIMDFmaOpStorageArray[i] ) ;
13251 : }
13252 0 : delete [] SgSIMDFmaOpStorageArray;
13253 : }
13254 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDLoad ) ;
13255 0 : std::cout << " SgSIMDLoad has size " << sizeOfActualPool << std::endl;
13256 0 : if ( 0 < sizeOfActualPool )
13257 : {
13258 0 : SgSIMDLoadStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13259 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13260 : {
13261 0 : new SgSIMDLoad ( SgSIMDLoadStorageArray[i] ) ;
13262 : }
13263 0 : delete [] SgSIMDLoadStorageArray;
13264 : }
13265 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDBroadcast ) ;
13266 0 : std::cout << " SgSIMDBroadcast has size " << sizeOfActualPool << std::endl;
13267 0 : if ( 0 < sizeOfActualPool )
13268 : {
13269 0 : SgSIMDBroadcastStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13270 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13271 : {
13272 0 : new SgSIMDBroadcast ( SgSIMDBroadcastStorageArray[i] ) ;
13273 : }
13274 0 : delete [] SgSIMDBroadcastStorageArray;
13275 : }
13276 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDStore ) ;
13277 0 : std::cout << " SgSIMDStore has size " << sizeOfActualPool << std::endl;
13278 0 : if ( 0 < sizeOfActualPool )
13279 : {
13280 0 : SgSIMDStoreStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13281 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13282 : {
13283 0 : new SgSIMDStore ( SgSIMDStoreStorageArray[i] ) ;
13284 : }
13285 0 : delete [] SgSIMDStoreStorageArray;
13286 : }
13287 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDPartialStore ) ;
13288 0 : std::cout << " SgSIMDPartialStore has size " << sizeOfActualPool << std::endl;
13289 0 : if ( 0 < sizeOfActualPool )
13290 : {
13291 0 : SgSIMDPartialStoreStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13292 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13293 : {
13294 0 : new SgSIMDPartialStore ( SgSIMDPartialStoreStorageArray[i] ) ;
13295 : }
13296 0 : delete [] SgSIMDPartialStoreStorageArray;
13297 : }
13298 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDScalarStore ) ;
13299 0 : std::cout << " SgSIMDScalarStore has size " << sizeOfActualPool << std::endl;
13300 0 : if ( 0 < sizeOfActualPool )
13301 : {
13302 0 : SgSIMDScalarStoreStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13303 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13304 : {
13305 0 : new SgSIMDScalarStore ( SgSIMDScalarStoreStorageArray[i] ) ;
13306 : }
13307 0 : delete [] SgSIMDScalarStoreStorageArray;
13308 : }
13309 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDGather ) ;
13310 0 : std::cout << " SgSIMDGather has size " << sizeOfActualPool << std::endl;
13311 0 : if ( 0 < sizeOfActualPool )
13312 : {
13313 0 : SgSIMDGatherStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13314 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13315 : {
13316 0 : new SgSIMDGather ( SgSIMDGatherStorageArray[i] ) ;
13317 : }
13318 0 : delete [] SgSIMDGatherStorageArray;
13319 : }
13320 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDExplicitGather ) ;
13321 0 : std::cout << " SgSIMDExplicitGather has size " << sizeOfActualPool << std::endl;
13322 0 : if ( 0 < sizeOfActualPool )
13323 : {
13324 0 : SgSIMDExplicitGatherStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13325 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13326 : {
13327 0 : new SgSIMDExplicitGather ( SgSIMDExplicitGatherStorageArray[i] ) ;
13328 : }
13329 0 : delete [] SgSIMDExplicitGatherStorageArray;
13330 : }
13331 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSIMDScatter ) ;
13332 0 : std::cout << " SgSIMDScatter has size " << sizeOfActualPool << std::endl;
13333 0 : if ( 0 < sizeOfActualPool )
13334 : {
13335 0 : SgSIMDScatterStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13336 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13337 : {
13338 0 : new SgSIMDScatter ( SgSIMDScatterStorageArray[i] ) ;
13339 : }
13340 0 : delete [] SgSIMDScatterStorageArray;
13341 : }
13342 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSizeOfOp ) ;
13343 0 : std::cout << " SgSizeOfOp has size " << sizeOfActualPool << std::endl;
13344 0 : if ( 0 < sizeOfActualPool )
13345 : {
13346 0 : SgSizeOfOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13347 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13348 : {
13349 0 : new SgSizeOfOp ( SgSizeOfOpStorageArray[i] ) ;
13350 : }
13351 0 : delete [] SgSizeOfOpStorageArray;
13352 : }
13353 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgAlignOfOp ) ;
13354 0 : std::cout << " SgAlignOfOp has size " << sizeOfActualPool << std::endl;
13355 0 : if ( 0 < sizeOfActualPool )
13356 : {
13357 0 : SgAlignOfOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13358 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13359 : {
13360 0 : new SgAlignOfOp ( SgAlignOfOpStorageArray[i] ) ;
13361 : }
13362 0 : delete [] SgAlignOfOpStorageArray;
13363 : }
13364 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSourceFile ) ;
13365 0 : std::cout << " SgSourceFile has size " << sizeOfActualPool << std::endl;
13366 0 : if ( 0 < sizeOfActualPool )
13367 : {
13368 0 : SgSourceFileStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13369 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13370 : {
13371 0 : new SgSourceFile ( SgSourceFileStorageArray[i] ) ;
13372 : }
13373 0 : delete [] SgSourceFileStorageArray;
13374 : }
13375 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSpaceshipOp ) ;
13376 0 : std::cout << " SgSpaceshipOp has size " << sizeOfActualPool << std::endl;
13377 0 : if ( 0 < sizeOfActualPool )
13378 : {
13379 0 : SgSpaceshipOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13380 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13381 : {
13382 0 : new SgSpaceshipOp ( SgSpaceshipOpStorageArray[i] ) ;
13383 : }
13384 0 : delete [] SgSpaceshipOpStorageArray;
13385 : }
13386 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSpawnStmt ) ;
13387 0 : std::cout << " SgSpawnStmt has size " << sizeOfActualPool << std::endl;
13388 0 : if ( 0 < sizeOfActualPool )
13389 : {
13390 0 : SgSpawnStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13391 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13392 : {
13393 0 : new SgSpawnStmt ( SgSpawnStmtStorageArray[i] ) ;
13394 : }
13395 0 : delete [] SgSpawnStmtStorageArray;
13396 : }
13397 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSyncAllStatement ) ;
13398 0 : std::cout << " SgSyncAllStatement has size " << sizeOfActualPool << std::endl;
13399 0 : if ( 0 < sizeOfActualPool )
13400 : {
13401 0 : SgSyncAllStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13402 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13403 : {
13404 0 : new SgSyncAllStatement ( SgSyncAllStatementStorageArray[i] ) ;
13405 : }
13406 0 : delete [] SgSyncAllStatementStorageArray;
13407 : }
13408 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSyncImagesStatement ) ;
13409 0 : std::cout << " SgSyncImagesStatement has size " << sizeOfActualPool << std::endl;
13410 0 : if ( 0 < sizeOfActualPool )
13411 : {
13412 0 : SgSyncImagesStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13413 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13414 : {
13415 0 : new SgSyncImagesStatement ( SgSyncImagesStatementStorageArray[i] ) ;
13416 : }
13417 0 : delete [] SgSyncImagesStatementStorageArray;
13418 : }
13419 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSyncMemoryStatement ) ;
13420 0 : std::cout << " SgSyncMemoryStatement has size " << sizeOfActualPool << std::endl;
13421 0 : if ( 0 < sizeOfActualPool )
13422 : {
13423 0 : SgSyncMemoryStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13424 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13425 : {
13426 0 : new SgSyncMemoryStatement ( SgSyncMemoryStatementStorageArray[i] ) ;
13427 : }
13428 0 : delete [] SgSyncMemoryStatementStorageArray;
13429 : }
13430 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSyncTeamStatement ) ;
13431 0 : std::cout << " SgSyncTeamStatement has size " << sizeOfActualPool << std::endl;
13432 0 : if ( 0 < sizeOfActualPool )
13433 : {
13434 0 : SgSyncTeamStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13435 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13436 : {
13437 0 : new SgSyncTeamStatement ( SgSyncTeamStatementStorageArray[i] ) ;
13438 : }
13439 0 : delete [] SgSyncTeamStatementStorageArray;
13440 : }
13441 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgLockStatement ) ;
13442 0 : std::cout << " SgLockStatement has size " << sizeOfActualPool << std::endl;
13443 0 : if ( 0 < sizeOfActualPool )
13444 : {
13445 0 : SgLockStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13446 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13447 : {
13448 0 : new SgLockStatement ( SgLockStatementStorageArray[i] ) ;
13449 : }
13450 0 : delete [] SgLockStatementStorageArray;
13451 : }
13452 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnlockStatement ) ;
13453 0 : std::cout << " SgUnlockStatement has size " << sizeOfActualPool << std::endl;
13454 0 : if ( 0 < sizeOfActualPool )
13455 : {
13456 0 : SgUnlockStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13457 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13458 : {
13459 0 : new SgUnlockStatement ( SgUnlockStatementStorageArray[i] ) ;
13460 : }
13461 0 : delete [] SgUnlockStatementStorageArray;
13462 : }
13463 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgProcessControlStatement ) ;
13464 0 : std::cout << " SgProcessControlStatement has size " << sizeOfActualPool << std::endl;
13465 0 : if ( 0 < sizeOfActualPool )
13466 : {
13467 0 : SgProcessControlStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13468 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13469 : {
13470 0 : new SgProcessControlStatement ( SgProcessControlStatementStorageArray[i] ) ;
13471 : }
13472 0 : delete [] SgProcessControlStatementStorageArray;
13473 : }
13474 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSpecialFunctionModifier ) ;
13475 0 : std::cout << " SgSpecialFunctionModifier has size " << sizeOfActualPool << std::endl;
13476 0 : if ( 0 < sizeOfActualPool )
13477 : {
13478 0 : SgSpecialFunctionModifierStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13479 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13480 : {
13481 0 : new SgSpecialFunctionModifier ( SgSpecialFunctionModifierStorageArray[i] ) ;
13482 : }
13483 0 : delete [] SgSpecialFunctionModifierStorageArray;
13484 : }
13485 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStatement ) ;
13486 0 : std::cout << " SgStatement has size " << sizeOfActualPool << std::endl;
13487 0 : if ( 0 < sizeOfActualPool )
13488 : {
13489 0 : SgStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13490 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13491 : {
13492 0 : new SgStatement ( SgStatementStorageArray[i] ) ;
13493 : }
13494 0 : delete [] SgStatementStorageArray;
13495 : }
13496 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStaticAssertionDeclaration ) ;
13497 0 : std::cout << " SgStaticAssertionDeclaration has size " << sizeOfActualPool << std::endl;
13498 0 : if ( 0 < sizeOfActualPool )
13499 : {
13500 0 : SgStaticAssertionDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13501 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13502 : {
13503 0 : new SgStaticAssertionDeclaration ( SgStaticAssertionDeclarationStorageArray[i] ) ;
13504 : }
13505 0 : delete [] SgStaticAssertionDeclarationStorageArray;
13506 : }
13507 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStmtDeclarationStatement ) ;
13508 0 : std::cout << " SgStmtDeclarationStatement has size " << sizeOfActualPool << std::endl;
13509 0 : if ( 0 < sizeOfActualPool )
13510 : {
13511 0 : SgStmtDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13512 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13513 : {
13514 0 : new SgStmtDeclarationStatement ( SgStmtDeclarationStatementStorageArray[i] ) ;
13515 : }
13516 0 : delete [] SgStmtDeclarationStatementStorageArray;
13517 : }
13518 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStatementExpression ) ;
13519 0 : std::cout << " SgStatementExpression has size " << sizeOfActualPool << std::endl;
13520 0 : if ( 0 < sizeOfActualPool )
13521 : {
13522 0 : SgStatementExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13523 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13524 : {
13525 0 : new SgStatementExpression ( SgStatementExpressionStorageArray[i] ) ;
13526 : }
13527 0 : delete [] SgStatementExpressionStorageArray;
13528 : }
13529 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStatementFunctionStatement ) ;
13530 0 : std::cout << " SgStatementFunctionStatement has size " << sizeOfActualPool << std::endl;
13531 0 : if ( 0 < sizeOfActualPool )
13532 : {
13533 0 : SgStatementFunctionStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13534 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13535 : {
13536 0 : new SgStatementFunctionStatement ( SgStatementFunctionStatementStorageArray[i] ) ;
13537 : }
13538 0 : delete [] SgStatementFunctionStatementStorageArray;
13539 : }
13540 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStorageModifier ) ;
13541 0 : std::cout << " SgStorageModifier has size " << sizeOfActualPool << std::endl;
13542 0 : if ( 0 < sizeOfActualPool )
13543 : {
13544 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13545 : {
13546 0 : new SgStorageModifier ( SgStorageModifierStorageArray[i] ) ;
13547 : }
13548 0 : delete [] SgStorageModifierStorageArray;
13549 : }
13550 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStringConversion ) ;
13551 0 : std::cout << " SgStringConversion has size " << sizeOfActualPool << std::endl;
13552 0 : if ( 0 < sizeOfActualPool )
13553 : {
13554 0 : SgStringConversionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13555 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13556 : {
13557 0 : new SgStringConversion ( SgStringConversionStorageArray[i] ) ;
13558 : }
13559 0 : delete [] SgStringConversionStorageArray;
13560 : }
13561 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStringKeyedBidirectionalGraph ) ;
13562 0 : std::cout << " SgStringKeyedBidirectionalGraph has size " << sizeOfActualPool << std::endl;
13563 0 : if ( 0 < sizeOfActualPool )
13564 : {
13565 0 : SgStringKeyedBidirectionalGraphStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13566 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13567 : {
13568 0 : new SgStringKeyedBidirectionalGraph ( SgStringKeyedBidirectionalGraphStorageArray[i] ) ;
13569 : }
13570 0 : delete [] SgStringKeyedBidirectionalGraphStorageArray;
13571 : }
13572 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStringVal ) ;
13573 0 : std::cout << " SgStringVal has size " << sizeOfActualPool << std::endl;
13574 0 : if ( 0 < sizeOfActualPool )
13575 : {
13576 0 : SgStringValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13577 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13578 : {
13579 0 : new SgStringVal ( SgStringValStorageArray[i] ) ;
13580 : }
13581 0 : delete [] SgStringValStorageArray;
13582 : }
13583 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgStructureModifier ) ;
13584 0 : std::cout << " SgStructureModifier has size " << sizeOfActualPool << std::endl;
13585 0 : if ( 0 < sizeOfActualPool )
13586 : {
13587 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13588 : {
13589 0 : new SgStructureModifier ( SgStructureModifierStorageArray[i] ) ;
13590 : }
13591 0 : delete [] SgStructureModifierStorageArray;
13592 : }
13593 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSubscriptExpression ) ;
13594 0 : std::cout << " SgSubscriptExpression has size " << sizeOfActualPool << std::endl;
13595 0 : if ( 0 < sizeOfActualPool )
13596 : {
13597 0 : SgSubscriptExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13598 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13599 : {
13600 0 : new SgSubscriptExpression ( SgSubscriptExpressionStorageArray[i] ) ;
13601 : }
13602 0 : delete [] SgSubscriptExpressionStorageArray;
13603 : }
13604 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSubtractOp ) ;
13605 0 : std::cout << " SgSubtractOp has size " << sizeOfActualPool << std::endl;
13606 0 : if ( 0 < sizeOfActualPool )
13607 : {
13608 0 : SgSubtractOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13609 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13610 : {
13611 0 : new SgSubtractOp ( SgSubtractOpStorageArray[i] ) ;
13612 : }
13613 0 : delete [] SgSubtractOpStorageArray;
13614 : }
13615 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSupport ) ;
13616 0 : std::cout << " SgSupport has size " << sizeOfActualPool << std::endl;
13617 0 : if ( 0 < sizeOfActualPool )
13618 : {
13619 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13620 : {
13621 0 : new SgSupport ( SgSupportStorageArray[i] ) ;
13622 : }
13623 0 : delete [] SgSupportStorageArray;
13624 : }
13625 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSwitchStatement ) ;
13626 0 : std::cout << " SgSwitchStatement has size " << sizeOfActualPool << std::endl;
13627 0 : if ( 0 < sizeOfActualPool )
13628 : {
13629 0 : SgSwitchStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13630 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13631 : {
13632 0 : new SgSwitchStatement ( SgSwitchStatementStorageArray[i] ) ;
13633 : }
13634 0 : delete [] SgSwitchStatementStorageArray;
13635 : }
13636 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSymbolTable ) ;
13637 0 : std::cout << " SgSymbolTable has size " << sizeOfActualPool << std::endl;
13638 0 : if ( 0 < sizeOfActualPool )
13639 : {
13640 0 : SgSymbolTableStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13641 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13642 : {
13643 0 : new SgSymbolTable ( SgSymbolTableStorageArray[i] ) ;
13644 : }
13645 0 : delete [] SgSymbolTableStorageArray;
13646 : }
13647 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateArgument ) ;
13648 0 : std::cout << " SgTemplateArgument has size " << sizeOfActualPool << std::endl;
13649 0 : if ( 0 < sizeOfActualPool )
13650 : {
13651 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13652 : {
13653 0 : new SgTemplateArgument ( SgTemplateArgumentStorageArray[i] ) ;
13654 : }
13655 0 : delete [] SgTemplateArgumentStorageArray;
13656 : }
13657 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateArgumentList ) ;
13658 0 : std::cout << " SgTemplateArgumentList has size " << sizeOfActualPool << std::endl;
13659 0 : if ( 0 < sizeOfActualPool )
13660 : {
13661 0 : SgTemplateArgumentListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13662 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13663 : {
13664 0 : new SgTemplateArgumentList ( SgTemplateArgumentListStorageArray[i] ) ;
13665 : }
13666 0 : delete [] SgTemplateArgumentListStorageArray;
13667 : }
13668 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateDeclaration ) ;
13669 0 : std::cout << " SgTemplateDeclaration has size " << sizeOfActualPool << std::endl;
13670 0 : if ( 0 < sizeOfActualPool )
13671 : {
13672 0 : SgTemplateDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13673 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13674 : {
13675 0 : new SgTemplateDeclaration ( SgTemplateDeclarationStorageArray[i] ) ;
13676 : }
13677 0 : delete [] SgTemplateDeclarationStorageArray;
13678 : }
13679 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateClassDeclaration ) ;
13680 0 : std::cout << " SgTemplateClassDeclaration has size " << sizeOfActualPool << std::endl;
13681 0 : if ( 0 < sizeOfActualPool )
13682 : {
13683 0 : SgTemplateClassDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13684 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13685 : {
13686 0 : new SgTemplateClassDeclaration ( SgTemplateClassDeclarationStorageArray[i] ) ;
13687 : }
13688 0 : delete [] SgTemplateClassDeclarationStorageArray;
13689 : }
13690 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateClassSymbol ) ;
13691 0 : std::cout << " SgTemplateClassSymbol has size " << sizeOfActualPool << std::endl;
13692 0 : if ( 0 < sizeOfActualPool )
13693 : {
13694 0 : SgTemplateClassSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13695 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13696 : {
13697 0 : new SgTemplateClassSymbol ( SgTemplateClassSymbolStorageArray[i] ) ;
13698 : }
13699 0 : delete [] SgTemplateClassSymbolStorageArray;
13700 : }
13701 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateFunctionDeclaration ) ;
13702 0 : std::cout << " SgTemplateFunctionDeclaration has size " << sizeOfActualPool << std::endl;
13703 0 : if ( 0 < sizeOfActualPool )
13704 : {
13705 0 : SgTemplateFunctionDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13706 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13707 : {
13708 0 : new SgTemplateFunctionDeclaration ( SgTemplateFunctionDeclarationStorageArray[i] ) ;
13709 : }
13710 0 : delete [] SgTemplateFunctionDeclarationStorageArray;
13711 : }
13712 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateFunctionRefExp ) ;
13713 0 : std::cout << " SgTemplateFunctionRefExp has size " << sizeOfActualPool << std::endl;
13714 0 : if ( 0 < sizeOfActualPool )
13715 : {
13716 0 : SgTemplateFunctionRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13717 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13718 : {
13719 0 : new SgTemplateFunctionRefExp ( SgTemplateFunctionRefExpStorageArray[i] ) ;
13720 : }
13721 0 : delete [] SgTemplateFunctionRefExpStorageArray;
13722 : }
13723 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateFunctionSymbol ) ;
13724 0 : std::cout << " SgTemplateFunctionSymbol has size " << sizeOfActualPool << std::endl;
13725 0 : if ( 0 < sizeOfActualPool )
13726 : {
13727 0 : SgTemplateFunctionSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13728 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13729 : {
13730 0 : new SgTemplateFunctionSymbol ( SgTemplateFunctionSymbolStorageArray[i] ) ;
13731 : }
13732 0 : delete [] SgTemplateFunctionSymbolStorageArray;
13733 : }
13734 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateMemberFunctionDeclaration ) ;
13735 0 : std::cout << " SgTemplateMemberFunctionDeclaration has size " << sizeOfActualPool << std::endl;
13736 0 : if ( 0 < sizeOfActualPool )
13737 : {
13738 0 : SgTemplateMemberFunctionDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13739 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13740 : {
13741 0 : new SgTemplateMemberFunctionDeclaration ( SgTemplateMemberFunctionDeclarationStorageArray[i] ) ;
13742 : }
13743 0 : delete [] SgTemplateMemberFunctionDeclarationStorageArray;
13744 : }
13745 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateMemberFunctionRefExp ) ;
13746 0 : std::cout << " SgTemplateMemberFunctionRefExp has size " << sizeOfActualPool << std::endl;
13747 0 : if ( 0 < sizeOfActualPool )
13748 : {
13749 0 : SgTemplateMemberFunctionRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13750 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13751 : {
13752 0 : new SgTemplateMemberFunctionRefExp ( SgTemplateMemberFunctionRefExpStorageArray[i] ) ;
13753 : }
13754 0 : delete [] SgTemplateMemberFunctionRefExpStorageArray;
13755 : }
13756 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateMemberFunctionSymbol ) ;
13757 0 : std::cout << " SgTemplateMemberFunctionSymbol has size " << sizeOfActualPool << std::endl;
13758 0 : if ( 0 < sizeOfActualPool )
13759 : {
13760 0 : SgTemplateMemberFunctionSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13761 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13762 : {
13763 0 : new SgTemplateMemberFunctionSymbol ( SgTemplateMemberFunctionSymbolStorageArray[i] ) ;
13764 : }
13765 0 : delete [] SgTemplateMemberFunctionSymbolStorageArray;
13766 : }
13767 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateTypedefDeclaration ) ;
13768 0 : std::cout << " SgTemplateTypedefDeclaration has size " << sizeOfActualPool << std::endl;
13769 0 : if ( 0 < sizeOfActualPool )
13770 : {
13771 0 : SgTemplateTypedefDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13772 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13773 : {
13774 0 : new SgTemplateTypedefDeclaration ( SgTemplateTypedefDeclarationStorageArray[i] ) ;
13775 : }
13776 0 : delete [] SgTemplateTypedefDeclarationStorageArray;
13777 : }
13778 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateTypedefSymbol ) ;
13779 0 : std::cout << " SgTemplateTypedefSymbol has size " << sizeOfActualPool << std::endl;
13780 0 : if ( 0 < sizeOfActualPool )
13781 : {
13782 0 : SgTemplateTypedefSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13783 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13784 : {
13785 0 : new SgTemplateTypedefSymbol ( SgTemplateTypedefSymbolStorageArray[i] ) ;
13786 : }
13787 0 : delete [] SgTemplateTypedefSymbolStorageArray;
13788 : }
13789 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateVariableDeclaration ) ;
13790 0 : std::cout << " SgTemplateVariableDeclaration has size " << sizeOfActualPool << std::endl;
13791 0 : if ( 0 < sizeOfActualPool )
13792 : {
13793 0 : SgTemplateVariableDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13794 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13795 : {
13796 0 : new SgTemplateVariableDeclaration ( SgTemplateVariableDeclarationStorageArray[i] ) ;
13797 : }
13798 0 : delete [] SgTemplateVariableDeclarationStorageArray;
13799 : }
13800 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateVariableSymbol ) ;
13801 0 : std::cout << " SgTemplateVariableSymbol has size " << sizeOfActualPool << std::endl;
13802 0 : if ( 0 < sizeOfActualPool )
13803 : {
13804 0 : SgTemplateVariableSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13805 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13806 : {
13807 0 : new SgTemplateVariableSymbol ( SgTemplateVariableSymbolStorageArray[i] ) ;
13808 : }
13809 0 : delete [] SgTemplateVariableSymbolStorageArray;
13810 : }
13811 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateClassDefinition ) ;
13812 0 : std::cout << " SgTemplateClassDefinition has size " << sizeOfActualPool << std::endl;
13813 0 : if ( 0 < sizeOfActualPool )
13814 : {
13815 0 : SgTemplateClassDefinitionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13816 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13817 : {
13818 0 : new SgTemplateClassDefinition ( SgTemplateClassDefinitionStorageArray[i] ) ;
13819 : }
13820 0 : delete [] SgTemplateClassDefinitionStorageArray;
13821 : }
13822 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateFunctionDefinition ) ;
13823 0 : std::cout << " SgTemplateFunctionDefinition has size " << sizeOfActualPool << std::endl;
13824 0 : if ( 0 < sizeOfActualPool )
13825 : {
13826 0 : SgTemplateFunctionDefinitionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13827 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13828 : {
13829 0 : new SgTemplateFunctionDefinition ( SgTemplateFunctionDefinitionStorageArray[i] ) ;
13830 : }
13831 0 : delete [] SgTemplateFunctionDefinitionStorageArray;
13832 : }
13833 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationDecl ) ;
13834 0 : std::cout << " SgTemplateInstantiationDecl has size " << sizeOfActualPool << std::endl;
13835 0 : if ( 0 < sizeOfActualPool )
13836 : {
13837 0 : SgTemplateInstantiationDeclStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13838 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13839 : {
13840 0 : new SgTemplateInstantiationDecl ( SgTemplateInstantiationDeclStorageArray[i] ) ;
13841 : }
13842 0 : delete [] SgTemplateInstantiationDeclStorageArray;
13843 : }
13844 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationDefn ) ;
13845 0 : std::cout << " SgTemplateInstantiationDefn has size " << sizeOfActualPool << std::endl;
13846 0 : if ( 0 < sizeOfActualPool )
13847 : {
13848 0 : SgTemplateInstantiationDefnStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13849 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13850 : {
13851 0 : new SgTemplateInstantiationDefn ( SgTemplateInstantiationDefnStorageArray[i] ) ;
13852 : }
13853 0 : delete [] SgTemplateInstantiationDefnStorageArray;
13854 : }
13855 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationDirectiveStatement ) ;
13856 0 : std::cout << " SgTemplateInstantiationDirectiveStatement has size " << sizeOfActualPool << std::endl;
13857 0 : if ( 0 < sizeOfActualPool )
13858 : {
13859 0 : SgTemplateInstantiationDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13860 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13861 : {
13862 0 : new SgTemplateInstantiationDirectiveStatement ( SgTemplateInstantiationDirectiveStatementStorageArray[i] ) ;
13863 : }
13864 0 : delete [] SgTemplateInstantiationDirectiveStatementStorageArray;
13865 : }
13866 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationFunctionDecl ) ;
13867 0 : std::cout << " SgTemplateInstantiationFunctionDecl has size " << sizeOfActualPool << std::endl;
13868 0 : if ( 0 < sizeOfActualPool )
13869 : {
13870 0 : SgTemplateInstantiationFunctionDeclStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13871 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13872 : {
13873 0 : new SgTemplateInstantiationFunctionDecl ( SgTemplateInstantiationFunctionDeclStorageArray[i] ) ;
13874 : }
13875 0 : delete [] SgTemplateInstantiationFunctionDeclStorageArray;
13876 : }
13877 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationMemberFunctionDecl ) ;
13878 0 : std::cout << " SgTemplateInstantiationMemberFunctionDecl has size " << sizeOfActualPool << std::endl;
13879 0 : if ( 0 < sizeOfActualPool )
13880 : {
13881 0 : SgTemplateInstantiationMemberFunctionDeclStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13882 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13883 : {
13884 0 : new SgTemplateInstantiationMemberFunctionDecl ( SgTemplateInstantiationMemberFunctionDeclStorageArray[i] ) ;
13885 : }
13886 0 : delete [] SgTemplateInstantiationMemberFunctionDeclStorageArray;
13887 : }
13888 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateInstantiationTypedefDeclaration ) ;
13889 0 : std::cout << " SgTemplateInstantiationTypedefDeclaration has size " << sizeOfActualPool << std::endl;
13890 0 : if ( 0 < sizeOfActualPool )
13891 : {
13892 0 : SgTemplateInstantiationTypedefDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13893 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13894 : {
13895 0 : new SgTemplateInstantiationTypedefDeclaration ( SgTemplateInstantiationTypedefDeclarationStorageArray[i] ) ;
13896 : }
13897 0 : delete [] SgTemplateInstantiationTypedefDeclarationStorageArray;
13898 : }
13899 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateParameter ) ;
13900 0 : std::cout << " SgTemplateParameter has size " << sizeOfActualPool << std::endl;
13901 0 : if ( 0 < sizeOfActualPool )
13902 : {
13903 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13904 : {
13905 0 : new SgTemplateParameter ( SgTemplateParameterStorageArray[i] ) ;
13906 : }
13907 0 : delete [] SgTemplateParameterStorageArray;
13908 : }
13909 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateParameterVal ) ;
13910 0 : std::cout << " SgTemplateParameterVal has size " << sizeOfActualPool << std::endl;
13911 0 : if ( 0 < sizeOfActualPool )
13912 : {
13913 0 : SgTemplateParameterValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13914 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13915 : {
13916 0 : new SgTemplateParameterVal ( SgTemplateParameterValStorageArray[i] ) ;
13917 : }
13918 0 : delete [] SgTemplateParameterValStorageArray;
13919 : }
13920 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateParameterList ) ;
13921 0 : std::cout << " SgTemplateParameterList has size " << sizeOfActualPool << std::endl;
13922 0 : if ( 0 < sizeOfActualPool )
13923 : {
13924 0 : SgTemplateParameterListStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13925 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13926 : {
13927 0 : new SgTemplateParameterList ( SgTemplateParameterListStorageArray[i] ) ;
13928 : }
13929 0 : delete [] SgTemplateParameterListStorageArray;
13930 : }
13931 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateSymbol ) ;
13932 0 : std::cout << " SgTemplateSymbol has size " << sizeOfActualPool << std::endl;
13933 0 : if ( 0 < sizeOfActualPool )
13934 : {
13935 0 : SgTemplateSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13936 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13937 : {
13938 0 : new SgTemplateSymbol ( SgTemplateSymbolStorageArray[i] ) ;
13939 : }
13940 0 : delete [] SgTemplateSymbolStorageArray;
13941 : }
13942 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTemplateType ) ;
13943 0 : std::cout << " SgTemplateType has size " << sizeOfActualPool << std::endl;
13944 0 : if ( 0 < sizeOfActualPool )
13945 : {
13946 0 : SgTemplateTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13947 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13948 : {
13949 0 : new SgTemplateType ( SgTemplateTypeStorageArray[i] ) ;
13950 : }
13951 0 : delete [] SgTemplateTypeStorageArray;
13952 : }
13953 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgThisExp ) ;
13954 0 : std::cout << " SgThisExp has size " << sizeOfActualPool << std::endl;
13955 0 : if ( 0 < sizeOfActualPool )
13956 : {
13957 0 : SgThisExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13958 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13959 : {
13960 0 : new SgThisExp ( SgThisExpStorageArray[i] ) ;
13961 : }
13962 0 : delete [] SgThisExpStorageArray;
13963 : }
13964 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeTraitBuiltinOperator ) ;
13965 0 : std::cout << " SgTypeTraitBuiltinOperator has size " << sizeOfActualPool << std::endl;
13966 0 : if ( 0 < sizeOfActualPool )
13967 : {
13968 0 : SgTypeTraitBuiltinOperatorStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13969 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13970 : {
13971 0 : new SgTypeTraitBuiltinOperator ( SgTypeTraitBuiltinOperatorStorageArray[i] ) ;
13972 : }
13973 0 : delete [] SgTypeTraitBuiltinOperatorStorageArray;
13974 : }
13975 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgSuperExp ) ;
13976 0 : std::cout << " SgSuperExp has size " << sizeOfActualPool << std::endl;
13977 0 : if ( 0 < sizeOfActualPool )
13978 : {
13979 0 : SgSuperExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13980 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13981 : {
13982 0 : new SgSuperExp ( SgSuperExpStorageArray[i] ) ;
13983 : }
13984 0 : delete [] SgSuperExpStorageArray;
13985 : }
13986 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgThrowOp ) ;
13987 0 : std::cout << " SgThrowOp has size " << sizeOfActualPool << std::endl;
13988 0 : if ( 0 < sizeOfActualPool )
13989 : {
13990 0 : SgThrowOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
13991 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
13992 : {
13993 0 : new SgThrowOp ( SgThrowOpStorageArray[i] ) ;
13994 : }
13995 0 : delete [] SgThrowOpStorageArray;
13996 : }
13997 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgToken ) ;
13998 0 : std::cout << " SgToken has size " << sizeOfActualPool << std::endl;
13999 0 : if ( 0 < sizeOfActualPool )
14000 : {
14001 0 : SgTokenStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14002 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14003 : {
14004 0 : new SgToken ( SgTokenStorageArray[i] ) ;
14005 : }
14006 0 : delete [] SgTokenStorageArray;
14007 : }
14008 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTryStmt ) ;
14009 0 : std::cout << " SgTryStmt has size " << sizeOfActualPool << std::endl;
14010 0 : if ( 0 < sizeOfActualPool )
14011 : {
14012 0 : SgTryStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14013 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14014 : {
14015 0 : new SgTryStmt ( SgTryStmtStorageArray[i] ) ;
14016 : }
14017 0 : delete [] SgTryStmtStorageArray;
14018 : }
14019 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTupleExp ) ;
14020 0 : std::cout << " SgTupleExp has size " << sizeOfActualPool << std::endl;
14021 0 : if ( 0 < sizeOfActualPool )
14022 : {
14023 0 : SgTupleExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14024 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14025 : {
14026 0 : new SgTupleExp ( SgTupleExpStorageArray[i] ) ;
14027 : }
14028 0 : delete [] SgTupleExpStorageArray;
14029 : }
14030 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgType ) ;
14031 0 : std::cout << " SgType has size " << sizeOfActualPool << std::endl;
14032 0 : if ( 0 < sizeOfActualPool )
14033 : {
14034 0 : SgTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14035 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14036 : {
14037 0 : new SgType ( SgTypeStorageArray[i] ) ;
14038 : }
14039 0 : delete [] SgTypeStorageArray;
14040 : }
14041 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeBool ) ;
14042 0 : std::cout << " SgTypeBool has size " << sizeOfActualPool << std::endl;
14043 0 : if ( 0 < sizeOfActualPool )
14044 : {
14045 0 : SgTypeBoolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14046 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14047 : {
14048 0 : new SgTypeBool ( SgTypeBoolStorageArray[i] ) ;
14049 : }
14050 0 : delete [] SgTypeBoolStorageArray;
14051 : }
14052 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeChar ) ;
14053 0 : std::cout << " SgTypeChar has size " << sizeOfActualPool << std::endl;
14054 0 : if ( 0 < sizeOfActualPool )
14055 : {
14056 0 : SgTypeCharStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14057 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14058 : {
14059 0 : new SgTypeChar ( SgTypeCharStorageArray[i] ) ;
14060 : }
14061 0 : delete [] SgTypeCharStorageArray;
14062 : }
14063 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeChar16 ) ;
14064 0 : std::cout << " SgTypeChar16 has size " << sizeOfActualPool << std::endl;
14065 0 : if ( 0 < sizeOfActualPool )
14066 : {
14067 0 : SgTypeChar16StorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14068 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14069 : {
14070 0 : new SgTypeChar16 ( SgTypeChar16StorageArray[i] ) ;
14071 : }
14072 0 : delete [] SgTypeChar16StorageArray;
14073 : }
14074 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeChar32 ) ;
14075 0 : std::cout << " SgTypeChar32 has size " << sizeOfActualPool << std::endl;
14076 0 : if ( 0 < sizeOfActualPool )
14077 : {
14078 0 : SgTypeChar32StorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14079 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14080 : {
14081 0 : new SgTypeChar32 ( SgTypeChar32StorageArray[i] ) ;
14082 : }
14083 0 : delete [] SgTypeChar32StorageArray;
14084 : }
14085 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeComplex ) ;
14086 0 : std::cout << " SgTypeComplex has size " << sizeOfActualPool << std::endl;
14087 0 : if ( 0 < sizeOfActualPool )
14088 : {
14089 0 : SgTypeComplexStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14090 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14091 : {
14092 0 : new SgTypeComplex ( SgTypeComplexStorageArray[i] ) ;
14093 : }
14094 0 : delete [] SgTypeComplexStorageArray;
14095 : }
14096 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeDefault ) ;
14097 0 : std::cout << " SgTypeDefault has size " << sizeOfActualPool << std::endl;
14098 0 : if ( 0 < sizeOfActualPool )
14099 : {
14100 0 : SgTypeDefaultStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14101 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14102 : {
14103 0 : new SgTypeDefault ( SgTypeDefaultStorageArray[i] ) ;
14104 : }
14105 0 : delete [] SgTypeDefaultStorageArray;
14106 : }
14107 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeExpression ) ;
14108 0 : std::cout << " SgTypeExpression has size " << sizeOfActualPool << std::endl;
14109 0 : if ( 0 < sizeOfActualPool )
14110 : {
14111 0 : SgTypeExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14112 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14113 : {
14114 0 : new SgTypeExpression ( SgTypeExpressionStorageArray[i] ) ;
14115 : }
14116 0 : delete [] SgTypeExpressionStorageArray;
14117 : }
14118 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeLabel ) ;
14119 0 : std::cout << " SgTypeLabel has size " << sizeOfActualPool << std::endl;
14120 0 : if ( 0 < sizeOfActualPool )
14121 : {
14122 0 : SgTypeLabelStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14123 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14124 : {
14125 0 : new SgTypeLabel ( SgTypeLabelStorageArray[i] ) ;
14126 : }
14127 0 : delete [] SgTypeLabelStorageArray;
14128 : }
14129 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeDouble ) ;
14130 0 : std::cout << " SgTypeDouble has size " << sizeOfActualPool << std::endl;
14131 0 : if ( 0 < sizeOfActualPool )
14132 : {
14133 0 : SgTypeDoubleStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14134 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14135 : {
14136 0 : new SgTypeDouble ( SgTypeDoubleStorageArray[i] ) ;
14137 : }
14138 0 : delete [] SgTypeDoubleStorageArray;
14139 : }
14140 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeEllipse ) ;
14141 0 : std::cout << " SgTypeEllipse has size " << sizeOfActualPool << std::endl;
14142 0 : if ( 0 < sizeOfActualPool )
14143 : {
14144 0 : SgTypeEllipseStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14145 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14146 : {
14147 0 : new SgTypeEllipse ( SgTypeEllipseStorageArray[i] ) ;
14148 : }
14149 0 : delete [] SgTypeEllipseStorageArray;
14150 : }
14151 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeFixed ) ;
14152 0 : std::cout << " SgTypeFixed has size " << sizeOfActualPool << std::endl;
14153 0 : if ( 0 < sizeOfActualPool )
14154 : {
14155 0 : SgTypeFixedStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14156 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14157 : {
14158 0 : new SgTypeFixed ( SgTypeFixedStorageArray[i] ) ;
14159 : }
14160 0 : delete [] SgTypeFixedStorageArray;
14161 : }
14162 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeFloat ) ;
14163 0 : std::cout << " SgTypeFloat has size " << sizeOfActualPool << std::endl;
14164 0 : if ( 0 < sizeOfActualPool )
14165 : {
14166 0 : SgTypeFloatStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14167 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14168 : {
14169 0 : new SgTypeFloat ( SgTypeFloatStorageArray[i] ) ;
14170 : }
14171 0 : delete [] SgTypeFloatStorageArray;
14172 : }
14173 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeFloat128 ) ;
14174 0 : std::cout << " SgTypeFloat128 has size " << sizeOfActualPool << std::endl;
14175 0 : if ( 0 < sizeOfActualPool )
14176 : {
14177 0 : SgTypeFloat128StorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14178 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14179 : {
14180 0 : new SgTypeFloat128 ( SgTypeFloat128StorageArray[i] ) ;
14181 : }
14182 0 : delete [] SgTypeFloat128StorageArray;
14183 : }
14184 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeFloat80 ) ;
14185 0 : std::cout << " SgTypeFloat80 has size " << sizeOfActualPool << std::endl;
14186 0 : if ( 0 < sizeOfActualPool )
14187 : {
14188 0 : SgTypeFloat80StorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14189 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14190 : {
14191 0 : new SgTypeFloat80 ( SgTypeFloat80StorageArray[i] ) ;
14192 : }
14193 0 : delete [] SgTypeFloat80StorageArray;
14194 : }
14195 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeGlobalVoid ) ;
14196 0 : std::cout << " SgTypeGlobalVoid has size " << sizeOfActualPool << std::endl;
14197 0 : if ( 0 < sizeOfActualPool )
14198 : {
14199 0 : SgTypeGlobalVoidStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14200 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14201 : {
14202 0 : new SgTypeGlobalVoid ( SgTypeGlobalVoidStorageArray[i] ) ;
14203 : }
14204 0 : delete [] SgTypeGlobalVoidStorageArray;
14205 : }
14206 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeIdOp ) ;
14207 0 : std::cout << " SgTypeIdOp has size " << sizeOfActualPool << std::endl;
14208 0 : if ( 0 < sizeOfActualPool )
14209 : {
14210 0 : SgTypeIdOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14211 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14212 : {
14213 0 : new SgTypeIdOp ( SgTypeIdOpStorageArray[i] ) ;
14214 : }
14215 0 : delete [] SgTypeIdOpStorageArray;
14216 : }
14217 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeImaginary ) ;
14218 0 : std::cout << " SgTypeImaginary has size " << sizeOfActualPool << std::endl;
14219 0 : if ( 0 < sizeOfActualPool )
14220 : {
14221 0 : SgTypeImaginaryStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14222 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14223 : {
14224 0 : new SgTypeImaginary ( SgTypeImaginaryStorageArray[i] ) ;
14225 : }
14226 0 : delete [] SgTypeImaginaryStorageArray;
14227 : }
14228 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeInt ) ;
14229 0 : std::cout << " SgTypeInt has size " << sizeOfActualPool << std::endl;
14230 0 : if ( 0 < sizeOfActualPool )
14231 : {
14232 0 : SgTypeIntStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14233 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14234 : {
14235 0 : new SgTypeInt ( SgTypeIntStorageArray[i] ) ;
14236 : }
14237 0 : delete [] SgTypeIntStorageArray;
14238 : }
14239 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeLong ) ;
14240 0 : std::cout << " SgTypeLong has size " << sizeOfActualPool << std::endl;
14241 0 : if ( 0 < sizeOfActualPool )
14242 : {
14243 0 : SgTypeLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14244 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14245 : {
14246 0 : new SgTypeLong ( SgTypeLongStorageArray[i] ) ;
14247 : }
14248 0 : delete [] SgTypeLongStorageArray;
14249 : }
14250 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeLongDouble ) ;
14251 0 : std::cout << " SgTypeLongDouble has size " << sizeOfActualPool << std::endl;
14252 0 : if ( 0 < sizeOfActualPool )
14253 : {
14254 0 : SgTypeLongDoubleStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14255 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14256 : {
14257 0 : new SgTypeLongDouble ( SgTypeLongDoubleStorageArray[i] ) ;
14258 : }
14259 0 : delete [] SgTypeLongDoubleStorageArray;
14260 : }
14261 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeLongLong ) ;
14262 0 : std::cout << " SgTypeLongLong has size " << sizeOfActualPool << std::endl;
14263 0 : if ( 0 < sizeOfActualPool )
14264 : {
14265 0 : SgTypeLongLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14266 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14267 : {
14268 0 : new SgTypeLongLong ( SgTypeLongLongStorageArray[i] ) ;
14269 : }
14270 0 : delete [] SgTypeLongLongStorageArray;
14271 : }
14272 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeModifier ) ;
14273 0 : std::cout << " SgTypeModifier has size " << sizeOfActualPool << std::endl;
14274 0 : if ( 0 < sizeOfActualPool )
14275 : {
14276 0 : SgTypeModifierStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14277 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14278 : {
14279 0 : new SgTypeModifier ( SgTypeModifierStorageArray[i] ) ;
14280 : }
14281 0 : delete [] SgTypeModifierStorageArray;
14282 : }
14283 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeMatrix ) ;
14284 0 : std::cout << " SgTypeMatrix has size " << sizeOfActualPool << std::endl;
14285 0 : if ( 0 < sizeOfActualPool )
14286 : {
14287 0 : SgTypeMatrixStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14288 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14289 : {
14290 0 : new SgTypeMatrix ( SgTypeMatrixStorageArray[i] ) ;
14291 : }
14292 0 : delete [] SgTypeMatrixStorageArray;
14293 : }
14294 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeTuple ) ;
14295 0 : std::cout << " SgTypeTuple has size " << sizeOfActualPool << std::endl;
14296 0 : if ( 0 < sizeOfActualPool )
14297 : {
14298 0 : SgTypeTupleStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14299 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14300 : {
14301 0 : new SgTypeTuple ( SgTypeTupleStorageArray[i] ) ;
14302 : }
14303 0 : delete [] SgTypeTupleStorageArray;
14304 : }
14305 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeNullptr ) ;
14306 0 : std::cout << " SgTypeNullptr has size " << sizeOfActualPool << std::endl;
14307 0 : if ( 0 < sizeOfActualPool )
14308 : {
14309 0 : SgTypeNullptrStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14310 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14311 : {
14312 0 : new SgTypeNullptr ( SgTypeNullptrStorageArray[i] ) ;
14313 : }
14314 0 : delete [] SgTypeNullptrStorageArray;
14315 : }
14316 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeOfType ) ;
14317 0 : std::cout << " SgTypeOfType has size " << sizeOfActualPool << std::endl;
14318 0 : if ( 0 < sizeOfActualPool )
14319 : {
14320 0 : SgTypeOfTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14321 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14322 : {
14323 0 : new SgTypeOfType ( SgTypeOfTypeStorageArray[i] ) ;
14324 : }
14325 0 : delete [] SgTypeOfTypeStorageArray;
14326 : }
14327 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeShort ) ;
14328 0 : std::cout << " SgTypeShort has size " << sizeOfActualPool << std::endl;
14329 0 : if ( 0 < sizeOfActualPool )
14330 : {
14331 0 : SgTypeShortStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14332 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14333 : {
14334 0 : new SgTypeShort ( SgTypeShortStorageArray[i] ) ;
14335 : }
14336 0 : delete [] SgTypeShortStorageArray;
14337 : }
14338 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSigned128bitInteger ) ;
14339 0 : std::cout << " SgTypeSigned128bitInteger has size " << sizeOfActualPool << std::endl;
14340 0 : if ( 0 < sizeOfActualPool )
14341 : {
14342 0 : SgTypeSigned128bitIntegerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14343 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14344 : {
14345 0 : new SgTypeSigned128bitInteger ( SgTypeSigned128bitIntegerStorageArray[i] ) ;
14346 : }
14347 0 : delete [] SgTypeSigned128bitIntegerStorageArray;
14348 : }
14349 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSignedChar ) ;
14350 0 : std::cout << " SgTypeSignedChar has size " << sizeOfActualPool << std::endl;
14351 0 : if ( 0 < sizeOfActualPool )
14352 : {
14353 0 : SgTypeSignedCharStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14354 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14355 : {
14356 0 : new SgTypeSignedChar ( SgTypeSignedCharStorageArray[i] ) ;
14357 : }
14358 0 : delete [] SgTypeSignedCharStorageArray;
14359 : }
14360 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSignedInt ) ;
14361 0 : std::cout << " SgTypeSignedInt has size " << sizeOfActualPool << std::endl;
14362 0 : if ( 0 < sizeOfActualPool )
14363 : {
14364 0 : SgTypeSignedIntStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14365 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14366 : {
14367 0 : new SgTypeSignedInt ( SgTypeSignedIntStorageArray[i] ) ;
14368 : }
14369 0 : delete [] SgTypeSignedIntStorageArray;
14370 : }
14371 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSignedLong ) ;
14372 0 : std::cout << " SgTypeSignedLong has size " << sizeOfActualPool << std::endl;
14373 0 : if ( 0 < sizeOfActualPool )
14374 : {
14375 0 : SgTypeSignedLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14376 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14377 : {
14378 0 : new SgTypeSignedLong ( SgTypeSignedLongStorageArray[i] ) ;
14379 : }
14380 0 : delete [] SgTypeSignedLongStorageArray;
14381 : }
14382 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSignedLongLong ) ;
14383 0 : std::cout << " SgTypeSignedLongLong has size " << sizeOfActualPool << std::endl;
14384 0 : if ( 0 < sizeOfActualPool )
14385 : {
14386 0 : SgTypeSignedLongLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14387 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14388 : {
14389 0 : new SgTypeSignedLongLong ( SgTypeSignedLongLongStorageArray[i] ) ;
14390 : }
14391 0 : delete [] SgTypeSignedLongLongStorageArray;
14392 : }
14393 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeSignedShort ) ;
14394 0 : std::cout << " SgTypeSignedShort has size " << sizeOfActualPool << std::endl;
14395 0 : if ( 0 < sizeOfActualPool )
14396 : {
14397 0 : SgTypeSignedShortStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14398 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14399 : {
14400 0 : new SgTypeSignedShort ( SgTypeSignedShortStorageArray[i] ) ;
14401 : }
14402 0 : delete [] SgTypeSignedShortStorageArray;
14403 : }
14404 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeString ) ;
14405 0 : std::cout << " SgTypeString has size " << sizeOfActualPool << std::endl;
14406 0 : if ( 0 < sizeOfActualPool )
14407 : {
14408 0 : SgTypeStringStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14409 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14410 : {
14411 0 : new SgTypeString ( SgTypeStringStorageArray[i] ) ;
14412 : }
14413 0 : delete [] SgTypeStringStorageArray;
14414 : }
14415 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnknown ) ;
14416 0 : std::cout << " SgTypeUnknown has size " << sizeOfActualPool << std::endl;
14417 0 : if ( 0 < sizeOfActualPool )
14418 : {
14419 0 : SgTypeUnknownStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14420 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14421 : {
14422 0 : new SgTypeUnknown ( SgTypeUnknownStorageArray[i] ) ;
14423 : }
14424 0 : delete [] SgTypeUnknownStorageArray;
14425 : }
14426 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsigned128bitInteger ) ;
14427 0 : std::cout << " SgTypeUnsigned128bitInteger has size " << sizeOfActualPool << std::endl;
14428 0 : if ( 0 < sizeOfActualPool )
14429 : {
14430 0 : SgTypeUnsigned128bitIntegerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14431 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14432 : {
14433 0 : new SgTypeUnsigned128bitInteger ( SgTypeUnsigned128bitIntegerStorageArray[i] ) ;
14434 : }
14435 0 : delete [] SgTypeUnsigned128bitIntegerStorageArray;
14436 : }
14437 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsignedChar ) ;
14438 0 : std::cout << " SgTypeUnsignedChar has size " << sizeOfActualPool << std::endl;
14439 0 : if ( 0 < sizeOfActualPool )
14440 : {
14441 0 : SgTypeUnsignedCharStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14442 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14443 : {
14444 0 : new SgTypeUnsignedChar ( SgTypeUnsignedCharStorageArray[i] ) ;
14445 : }
14446 0 : delete [] SgTypeUnsignedCharStorageArray;
14447 : }
14448 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsignedInt ) ;
14449 0 : std::cout << " SgTypeUnsignedInt has size " << sizeOfActualPool << std::endl;
14450 0 : if ( 0 < sizeOfActualPool )
14451 : {
14452 0 : SgTypeUnsignedIntStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14453 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14454 : {
14455 0 : new SgTypeUnsignedInt ( SgTypeUnsignedIntStorageArray[i] ) ;
14456 : }
14457 0 : delete [] SgTypeUnsignedIntStorageArray;
14458 : }
14459 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsignedLong ) ;
14460 0 : std::cout << " SgTypeUnsignedLong has size " << sizeOfActualPool << std::endl;
14461 0 : if ( 0 < sizeOfActualPool )
14462 : {
14463 0 : SgTypeUnsignedLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14464 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14465 : {
14466 0 : new SgTypeUnsignedLong ( SgTypeUnsignedLongStorageArray[i] ) ;
14467 : }
14468 0 : delete [] SgTypeUnsignedLongStorageArray;
14469 : }
14470 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsignedLongLong ) ;
14471 0 : std::cout << " SgTypeUnsignedLongLong has size " << sizeOfActualPool << std::endl;
14472 0 : if ( 0 < sizeOfActualPool )
14473 : {
14474 0 : SgTypeUnsignedLongLongStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14475 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14476 : {
14477 0 : new SgTypeUnsignedLongLong ( SgTypeUnsignedLongLongStorageArray[i] ) ;
14478 : }
14479 0 : delete [] SgTypeUnsignedLongLongStorageArray;
14480 : }
14481 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeUnsignedShort ) ;
14482 0 : std::cout << " SgTypeUnsignedShort has size " << sizeOfActualPool << std::endl;
14483 0 : if ( 0 < sizeOfActualPool )
14484 : {
14485 0 : SgTypeUnsignedShortStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14486 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14487 : {
14488 0 : new SgTypeUnsignedShort ( SgTypeUnsignedShortStorageArray[i] ) ;
14489 : }
14490 0 : delete [] SgTypeUnsignedShortStorageArray;
14491 : }
14492 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeVoid ) ;
14493 0 : std::cout << " SgTypeVoid has size " << sizeOfActualPool << std::endl;
14494 0 : if ( 0 < sizeOfActualPool )
14495 : {
14496 0 : SgTypeVoidStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14497 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14498 : {
14499 0 : new SgTypeVoid ( SgTypeVoidStorageArray[i] ) ;
14500 : }
14501 0 : delete [] SgTypeVoidStorageArray;
14502 : }
14503 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeWchar ) ;
14504 0 : std::cout << " SgTypeWchar has size " << sizeOfActualPool << std::endl;
14505 0 : if ( 0 < sizeOfActualPool )
14506 : {
14507 0 : SgTypeWcharStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14508 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14509 : {
14510 0 : new SgTypeWchar ( SgTypeWcharStorageArray[i] ) ;
14511 : }
14512 0 : delete [] SgTypeWcharStorageArray;
14513 : }
14514 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypedefDeclaration ) ;
14515 0 : std::cout << " SgTypedefDeclaration has size " << sizeOfActualPool << std::endl;
14516 0 : if ( 0 < sizeOfActualPool )
14517 : {
14518 0 : SgTypedefDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14519 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14520 : {
14521 0 : new SgTypedefDeclaration ( SgTypedefDeclarationStorageArray[i] ) ;
14522 : }
14523 0 : delete [] SgTypedefDeclarationStorageArray;
14524 : }
14525 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypedefSeq ) ;
14526 0 : std::cout << " SgTypedefSeq has size " << sizeOfActualPool << std::endl;
14527 0 : if ( 0 < sizeOfActualPool )
14528 : {
14529 0 : SgTypedefSeqStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14530 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14531 : {
14532 0 : new SgTypedefSeq ( SgTypedefSeqStorageArray[i] ) ;
14533 : }
14534 0 : delete [] SgTypedefSeqStorageArray;
14535 : }
14536 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypedefSymbol ) ;
14537 0 : std::cout << " SgTypedefSymbol has size " << sizeOfActualPool << std::endl;
14538 0 : if ( 0 < sizeOfActualPool )
14539 : {
14540 0 : SgTypedefSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14541 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14542 : {
14543 0 : new SgTypedefSymbol ( SgTypedefSymbolStorageArray[i] ) ;
14544 : }
14545 0 : delete [] SgTypedefSymbolStorageArray;
14546 : }
14547 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypedefType ) ;
14548 0 : std::cout << " SgTypedefType has size " << sizeOfActualPool << std::endl;
14549 0 : if ( 0 < sizeOfActualPool )
14550 : {
14551 0 : SgTypedefTypeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14552 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14553 : {
14554 0 : new SgTypedefType ( SgTypedefTypeStorageArray[i] ) ;
14555 : }
14556 0 : delete [] SgTypedefTypeStorageArray;
14557 : }
14558 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUPC_AccessModifier ) ;
14559 0 : std::cout << " SgUPC_AccessModifier has size " << sizeOfActualPool << std::endl;
14560 0 : if ( 0 < sizeOfActualPool )
14561 : {
14562 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14563 : {
14564 0 : new SgUPC_AccessModifier ( SgUPC_AccessModifierStorageArray[i] ) ;
14565 : }
14566 0 : delete [] SgUPC_AccessModifierStorageArray;
14567 : }
14568 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnaryAddOp ) ;
14569 0 : std::cout << " SgUnaryAddOp has size " << sizeOfActualPool << std::endl;
14570 0 : if ( 0 < sizeOfActualPool )
14571 : {
14572 0 : SgUnaryAddOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14573 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14574 : {
14575 0 : new SgUnaryAddOp ( SgUnaryAddOpStorageArray[i] ) ;
14576 : }
14577 0 : delete [] SgUnaryAddOpStorageArray;
14578 : }
14579 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnaryOp ) ;
14580 0 : std::cout << " SgUnaryOp has size " << sizeOfActualPool << std::endl;
14581 0 : if ( 0 < sizeOfActualPool )
14582 : {
14583 0 : SgUnaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14584 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14585 : {
14586 0 : new SgUnaryOp ( SgUnaryOpStorageArray[i] ) ;
14587 : }
14588 0 : delete [] SgUnaryOpStorageArray;
14589 : }
14590 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUndefDirectiveStatement ) ;
14591 0 : std::cout << " SgUndefDirectiveStatement has size " << sizeOfActualPool << std::endl;
14592 0 : if ( 0 < sizeOfActualPool )
14593 : {
14594 0 : SgUndefDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14595 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14596 : {
14597 0 : new SgUndefDirectiveStatement ( SgUndefDirectiveStatementStorageArray[i] ) ;
14598 : }
14599 0 : delete [] SgUndefDirectiveStatementStorageArray;
14600 : }
14601 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUndirectedGraphEdge ) ;
14602 0 : std::cout << " SgUndirectedGraphEdge has size " << sizeOfActualPool << std::endl;
14603 0 : if ( 0 < sizeOfActualPool )
14604 : {
14605 0 : SgUndirectedGraphEdgeStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14606 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14607 : {
14608 0 : new SgUndirectedGraphEdge ( SgUndirectedGraphEdgeStorageArray[i] ) ;
14609 : }
14610 0 : delete [] SgUndirectedGraphEdgeStorageArray;
14611 : }
14612 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnknownArrayOrFunctionReference ) ;
14613 0 : std::cout << " SgUnknownArrayOrFunctionReference has size " << sizeOfActualPool << std::endl;
14614 0 : if ( 0 < sizeOfActualPool )
14615 : {
14616 0 : SgUnknownArrayOrFunctionReferenceStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14617 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14618 : {
14619 0 : new SgUnknownArrayOrFunctionReference ( SgUnknownArrayOrFunctionReferenceStorageArray[i] ) ;
14620 : }
14621 0 : delete [] SgUnknownArrayOrFunctionReferenceStorageArray;
14622 : }
14623 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnknownFile ) ;
14624 0 : std::cout << " SgUnknownFile has size " << sizeOfActualPool << std::endl;
14625 0 : if ( 0 < sizeOfActualPool )
14626 : {
14627 0 : SgUnknownFileStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14628 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14629 : {
14630 0 : new SgUnknownFile ( SgUnknownFileStorageArray[i] ) ;
14631 : }
14632 0 : delete [] SgUnknownFileStorageArray;
14633 : }
14634 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnparse_Info ) ;
14635 0 : std::cout << " SgUnparse_Info has size " << sizeOfActualPool << std::endl;
14636 0 : if ( 0 < sizeOfActualPool )
14637 : {
14638 0 : SgUnparse_InfoStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14639 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14640 : {
14641 0 : new SgUnparse_Info ( SgUnparse_InfoStorageArray[i] ) ;
14642 : }
14643 0 : delete [] SgUnparse_InfoStorageArray;
14644 : }
14645 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnsignedCharVal ) ;
14646 0 : std::cout << " SgUnsignedCharVal has size " << sizeOfActualPool << std::endl;
14647 0 : if ( 0 < sizeOfActualPool )
14648 : {
14649 0 : SgUnsignedCharValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14650 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14651 : {
14652 0 : new SgUnsignedCharVal ( SgUnsignedCharValStorageArray[i] ) ;
14653 : }
14654 0 : delete [] SgUnsignedCharValStorageArray;
14655 : }
14656 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnsignedIntVal ) ;
14657 0 : std::cout << " SgUnsignedIntVal has size " << sizeOfActualPool << std::endl;
14658 0 : if ( 0 < sizeOfActualPool )
14659 : {
14660 0 : SgUnsignedIntValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14661 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14662 : {
14663 0 : new SgUnsignedIntVal ( SgUnsignedIntValStorageArray[i] ) ;
14664 : }
14665 0 : delete [] SgUnsignedIntValStorageArray;
14666 : }
14667 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnsignedLongLongIntVal ) ;
14668 0 : std::cout << " SgUnsignedLongLongIntVal has size " << sizeOfActualPool << std::endl;
14669 0 : if ( 0 < sizeOfActualPool )
14670 : {
14671 0 : SgUnsignedLongLongIntValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14672 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14673 : {
14674 0 : new SgUnsignedLongLongIntVal ( SgUnsignedLongLongIntValStorageArray[i] ) ;
14675 : }
14676 0 : delete [] SgUnsignedLongLongIntValStorageArray;
14677 : }
14678 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnsignedLongVal ) ;
14679 0 : std::cout << " SgUnsignedLongVal has size " << sizeOfActualPool << std::endl;
14680 0 : if ( 0 < sizeOfActualPool )
14681 : {
14682 0 : SgUnsignedLongValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14683 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14684 : {
14685 0 : new SgUnsignedLongVal ( SgUnsignedLongValStorageArray[i] ) ;
14686 : }
14687 0 : delete [] SgUnsignedLongValStorageArray;
14688 : }
14689 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUnsignedShortVal ) ;
14690 0 : std::cout << " SgUnsignedShortVal has size " << sizeOfActualPool << std::endl;
14691 0 : if ( 0 < sizeOfActualPool )
14692 : {
14693 0 : SgUnsignedShortValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14694 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14695 : {
14696 0 : new SgUnsignedShortVal ( SgUnsignedShortValStorageArray[i] ) ;
14697 : }
14698 0 : delete [] SgUnsignedShortValStorageArray;
14699 : }
14700 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcBarrierStatement ) ;
14701 0 : std::cout << " SgUpcBarrierStatement has size " << sizeOfActualPool << std::endl;
14702 0 : if ( 0 < sizeOfActualPool )
14703 : {
14704 0 : SgUpcBarrierStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14705 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14706 : {
14707 0 : new SgUpcBarrierStatement ( SgUpcBarrierStatementStorageArray[i] ) ;
14708 : }
14709 0 : delete [] SgUpcBarrierStatementStorageArray;
14710 : }
14711 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcBlocksizeofExpression ) ;
14712 0 : std::cout << " SgUpcBlocksizeofExpression has size " << sizeOfActualPool << std::endl;
14713 0 : if ( 0 < sizeOfActualPool )
14714 : {
14715 0 : SgUpcBlocksizeofExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14716 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14717 : {
14718 0 : new SgUpcBlocksizeofExpression ( SgUpcBlocksizeofExpressionStorageArray[i] ) ;
14719 : }
14720 0 : delete [] SgUpcBlocksizeofExpressionStorageArray;
14721 : }
14722 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcElemsizeofExpression ) ;
14723 0 : std::cout << " SgUpcElemsizeofExpression has size " << sizeOfActualPool << std::endl;
14724 0 : if ( 0 < sizeOfActualPool )
14725 : {
14726 0 : SgUpcElemsizeofExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14727 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14728 : {
14729 0 : new SgUpcElemsizeofExpression ( SgUpcElemsizeofExpressionStorageArray[i] ) ;
14730 : }
14731 0 : delete [] SgUpcElemsizeofExpressionStorageArray;
14732 : }
14733 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcFenceStatement ) ;
14734 0 : std::cout << " SgUpcFenceStatement has size " << sizeOfActualPool << std::endl;
14735 0 : if ( 0 < sizeOfActualPool )
14736 : {
14737 0 : SgUpcFenceStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14738 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14739 : {
14740 0 : new SgUpcFenceStatement ( SgUpcFenceStatementStorageArray[i] ) ;
14741 : }
14742 0 : delete [] SgUpcFenceStatementStorageArray;
14743 : }
14744 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcForAllStatement ) ;
14745 0 : std::cout << " SgUpcForAllStatement has size " << sizeOfActualPool << std::endl;
14746 0 : if ( 0 < sizeOfActualPool )
14747 : {
14748 0 : SgUpcForAllStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14749 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14750 : {
14751 0 : new SgUpcForAllStatement ( SgUpcForAllStatementStorageArray[i] ) ;
14752 : }
14753 0 : delete [] SgUpcForAllStatementStorageArray;
14754 : }
14755 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcLocalsizeofExpression ) ;
14756 0 : std::cout << " SgUpcLocalsizeofExpression has size " << sizeOfActualPool << std::endl;
14757 0 : if ( 0 < sizeOfActualPool )
14758 : {
14759 0 : SgUpcLocalsizeofExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14760 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14761 : {
14762 0 : new SgUpcLocalsizeofExpression ( SgUpcLocalsizeofExpressionStorageArray[i] ) ;
14763 : }
14764 0 : delete [] SgUpcLocalsizeofExpressionStorageArray;
14765 : }
14766 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcMythread ) ;
14767 0 : std::cout << " SgUpcMythread has size " << sizeOfActualPool << std::endl;
14768 0 : if ( 0 < sizeOfActualPool )
14769 : {
14770 0 : SgUpcMythreadStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14771 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14772 : {
14773 0 : new SgUpcMythread ( SgUpcMythreadStorageArray[i] ) ;
14774 : }
14775 0 : delete [] SgUpcMythreadStorageArray;
14776 : }
14777 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcNotifyStatement ) ;
14778 0 : std::cout << " SgUpcNotifyStatement has size " << sizeOfActualPool << std::endl;
14779 0 : if ( 0 < sizeOfActualPool )
14780 : {
14781 0 : SgUpcNotifyStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14782 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14783 : {
14784 0 : new SgUpcNotifyStatement ( SgUpcNotifyStatementStorageArray[i] ) ;
14785 : }
14786 0 : delete [] SgUpcNotifyStatementStorageArray;
14787 : }
14788 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcThreads ) ;
14789 0 : std::cout << " SgUpcThreads has size " << sizeOfActualPool << std::endl;
14790 0 : if ( 0 < sizeOfActualPool )
14791 : {
14792 0 : SgUpcThreadsStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14793 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14794 : {
14795 0 : new SgUpcThreads ( SgUpcThreadsStorageArray[i] ) ;
14796 : }
14797 0 : delete [] SgUpcThreadsStorageArray;
14798 : }
14799 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUpcWaitStatement ) ;
14800 0 : std::cout << " SgUpcWaitStatement has size " << sizeOfActualPool << std::endl;
14801 0 : if ( 0 < sizeOfActualPool )
14802 : {
14803 0 : SgUpcWaitStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14804 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14805 : {
14806 0 : new SgUpcWaitStatement ( SgUpcWaitStatementStorageArray[i] ) ;
14807 : }
14808 0 : delete [] SgUpcWaitStatementStorageArray;
14809 : }
14810 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUseStatement ) ;
14811 0 : std::cout << " SgUseStatement has size " << sizeOfActualPool << std::endl;
14812 0 : if ( 0 < sizeOfActualPool )
14813 : {
14814 0 : SgUseStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14815 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14816 : {
14817 0 : new SgUseStatement ( SgUseStatementStorageArray[i] ) ;
14818 : }
14819 0 : delete [] SgUseStatementStorageArray;
14820 : }
14821 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUserDefinedBinaryOp ) ;
14822 0 : std::cout << " SgUserDefinedBinaryOp has size " << sizeOfActualPool << std::endl;
14823 0 : if ( 0 < sizeOfActualPool )
14824 : {
14825 0 : SgUserDefinedBinaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14826 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14827 : {
14828 0 : new SgUserDefinedBinaryOp ( SgUserDefinedBinaryOpStorageArray[i] ) ;
14829 : }
14830 0 : delete [] SgUserDefinedBinaryOpStorageArray;
14831 : }
14832 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUserDefinedUnaryOp ) ;
14833 0 : std::cout << " SgUserDefinedUnaryOp has size " << sizeOfActualPool << std::endl;
14834 0 : if ( 0 < sizeOfActualPool )
14835 : {
14836 0 : SgUserDefinedUnaryOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14837 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14838 : {
14839 0 : new SgUserDefinedUnaryOp ( SgUserDefinedUnaryOpStorageArray[i] ) ;
14840 : }
14841 0 : delete [] SgUserDefinedUnaryOpStorageArray;
14842 : }
14843 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUsingDeclarationStatement ) ;
14844 0 : std::cout << " SgUsingDeclarationStatement has size " << sizeOfActualPool << std::endl;
14845 0 : if ( 0 < sizeOfActualPool )
14846 : {
14847 0 : SgUsingDeclarationStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14848 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14849 : {
14850 0 : new SgUsingDeclarationStatement ( SgUsingDeclarationStatementStorageArray[i] ) ;
14851 : }
14852 0 : delete [] SgUsingDeclarationStatementStorageArray;
14853 : }
14854 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgUsingDirectiveStatement ) ;
14855 0 : std::cout << " SgUsingDirectiveStatement has size " << sizeOfActualPool << std::endl;
14856 0 : if ( 0 < sizeOfActualPool )
14857 : {
14858 0 : SgUsingDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14859 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14860 : {
14861 0 : new SgUsingDirectiveStatement ( SgUsingDirectiveStatementStorageArray[i] ) ;
14862 : }
14863 0 : delete [] SgUsingDirectiveStatementStorageArray;
14864 : }
14865 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgValueExp ) ;
14866 0 : std::cout << " SgValueExp has size " << sizeOfActualPool << std::endl;
14867 0 : if ( 0 < sizeOfActualPool )
14868 : {
14869 0 : SgValueExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14870 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14871 : {
14872 0 : new SgValueExp ( SgValueExpStorageArray[i] ) ;
14873 : }
14874 0 : delete [] SgValueExpStorageArray;
14875 : }
14876 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarArgCopyOp ) ;
14877 0 : std::cout << " SgVarArgCopyOp has size " << sizeOfActualPool << std::endl;
14878 0 : if ( 0 < sizeOfActualPool )
14879 : {
14880 0 : SgVarArgCopyOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14881 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14882 : {
14883 0 : new SgVarArgCopyOp ( SgVarArgCopyOpStorageArray[i] ) ;
14884 : }
14885 0 : delete [] SgVarArgCopyOpStorageArray;
14886 : }
14887 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarArgEndOp ) ;
14888 0 : std::cout << " SgVarArgEndOp has size " << sizeOfActualPool << std::endl;
14889 0 : if ( 0 < sizeOfActualPool )
14890 : {
14891 0 : SgVarArgEndOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14892 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14893 : {
14894 0 : new SgVarArgEndOp ( SgVarArgEndOpStorageArray[i] ) ;
14895 : }
14896 0 : delete [] SgVarArgEndOpStorageArray;
14897 : }
14898 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarArgOp ) ;
14899 0 : std::cout << " SgVarArgOp has size " << sizeOfActualPool << std::endl;
14900 0 : if ( 0 < sizeOfActualPool )
14901 : {
14902 0 : SgVarArgOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14903 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14904 : {
14905 0 : new SgVarArgOp ( SgVarArgOpStorageArray[i] ) ;
14906 : }
14907 0 : delete [] SgVarArgOpStorageArray;
14908 : }
14909 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarArgStartOneOperandOp ) ;
14910 0 : std::cout << " SgVarArgStartOneOperandOp has size " << sizeOfActualPool << std::endl;
14911 0 : if ( 0 < sizeOfActualPool )
14912 : {
14913 0 : SgVarArgStartOneOperandOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14914 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14915 : {
14916 0 : new SgVarArgStartOneOperandOp ( SgVarArgStartOneOperandOpStorageArray[i] ) ;
14917 : }
14918 0 : delete [] SgVarArgStartOneOperandOpStorageArray;
14919 : }
14920 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarArgStartOp ) ;
14921 0 : std::cout << " SgVarArgStartOp has size " << sizeOfActualPool << std::endl;
14922 0 : if ( 0 < sizeOfActualPool )
14923 : {
14924 0 : SgVarArgStartOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14925 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14926 : {
14927 0 : new SgVarArgStartOp ( SgVarArgStartOpStorageArray[i] ) ;
14928 : }
14929 0 : delete [] SgVarArgStartOpStorageArray;
14930 : }
14931 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVarRefExp ) ;
14932 0 : std::cout << " SgVarRefExp has size " << sizeOfActualPool << std::endl;
14933 0 : if ( 0 < sizeOfActualPool )
14934 : {
14935 0 : SgVarRefExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14936 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14937 : {
14938 0 : new SgVarRefExp ( SgVarRefExpStorageArray[i] ) ;
14939 : }
14940 0 : delete [] SgVarRefExpStorageArray;
14941 : }
14942 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVariableDeclaration ) ;
14943 0 : std::cout << " SgVariableDeclaration has size " << sizeOfActualPool << std::endl;
14944 0 : if ( 0 < sizeOfActualPool )
14945 : {
14946 0 : SgVariableDeclarationStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14947 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14948 : {
14949 0 : new SgVariableDeclaration ( SgVariableDeclarationStorageArray[i] ) ;
14950 : }
14951 0 : delete [] SgVariableDeclarationStorageArray;
14952 : }
14953 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVariableDefinition ) ;
14954 0 : std::cout << " SgVariableDefinition has size " << sizeOfActualPool << std::endl;
14955 0 : if ( 0 < sizeOfActualPool )
14956 : {
14957 0 : SgVariableDefinitionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14958 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14959 : {
14960 0 : new SgVariableDefinition ( SgVariableDefinitionStorageArray[i] ) ;
14961 : }
14962 0 : delete [] SgVariableDefinitionStorageArray;
14963 : }
14964 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVariableSymbol ) ;
14965 0 : std::cout << " SgVariableSymbol has size " << sizeOfActualPool << std::endl;
14966 0 : if ( 0 < sizeOfActualPool )
14967 : {
14968 0 : SgVariableSymbolStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14969 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14970 : {
14971 0 : new SgVariableSymbol ( SgVariableSymbolStorageArray[i] ) ;
14972 : }
14973 0 : delete [] SgVariableSymbolStorageArray;
14974 : }
14975 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVariantExpression ) ;
14976 0 : std::cout << " SgVariantExpression has size " << sizeOfActualPool << std::endl;
14977 0 : if ( 0 < sizeOfActualPool )
14978 : {
14979 0 : SgVariantExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14980 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14981 : {
14982 0 : new SgVariantExpression ( SgVariantExpressionStorageArray[i] ) ;
14983 : }
14984 0 : delete [] SgVariantExpressionStorageArray;
14985 : }
14986 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVariantStatement ) ;
14987 0 : std::cout << " SgVariantStatement has size " << sizeOfActualPool << std::endl;
14988 0 : if ( 0 < sizeOfActualPool )
14989 : {
14990 0 : SgVariantStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
14991 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
14992 : {
14993 0 : new SgVariantStatement ( SgVariantStatementStorageArray[i] ) ;
14994 : }
14995 0 : delete [] SgVariantStatementStorageArray;
14996 : }
14997 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgVoidVal ) ;
14998 0 : std::cout << " SgVoidVal has size " << sizeOfActualPool << std::endl;
14999 0 : if ( 0 < sizeOfActualPool )
15000 : {
15001 0 : SgVoidValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15002 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15003 : {
15004 0 : new SgVoidVal ( SgVoidValStorageArray[i] ) ;
15005 : }
15006 0 : delete [] SgVoidValStorageArray;
15007 : }
15008 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWaitStatement ) ;
15009 0 : std::cout << " SgWaitStatement has size " << sizeOfActualPool << std::endl;
15010 0 : if ( 0 < sizeOfActualPool )
15011 : {
15012 0 : SgWaitStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15013 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15014 : {
15015 0 : new SgWaitStatement ( SgWaitStatementStorageArray[i] ) ;
15016 : }
15017 0 : delete [] SgWaitStatementStorageArray;
15018 : }
15019 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWarningDirectiveStatement ) ;
15020 0 : std::cout << " SgWarningDirectiveStatement has size " << sizeOfActualPool << std::endl;
15021 0 : if ( 0 < sizeOfActualPool )
15022 : {
15023 0 : SgWarningDirectiveStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15024 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15025 : {
15026 0 : new SgWarningDirectiveStatement ( SgWarningDirectiveStatementStorageArray[i] ) ;
15027 : }
15028 0 : delete [] SgWarningDirectiveStatementStorageArray;
15029 : }
15030 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWithStatement ) ;
15031 0 : std::cout << " SgWithStatement has size " << sizeOfActualPool << std::endl;
15032 0 : if ( 0 < sizeOfActualPool )
15033 : {
15034 0 : SgWithStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15035 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15036 : {
15037 0 : new SgWithStatement ( SgWithStatementStorageArray[i] ) ;
15038 : }
15039 0 : delete [] SgWithStatementStorageArray;
15040 : }
15041 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWcharVal ) ;
15042 0 : std::cout << " SgWcharVal has size " << sizeOfActualPool << std::endl;
15043 0 : if ( 0 < sizeOfActualPool )
15044 : {
15045 0 : SgWcharValStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15046 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15047 : {
15048 0 : new SgWcharVal ( SgWcharValStorageArray[i] ) ;
15049 : }
15050 0 : delete [] SgWcharValStorageArray;
15051 : }
15052 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWhereStatement ) ;
15053 0 : std::cout << " SgWhereStatement has size " << sizeOfActualPool << std::endl;
15054 0 : if ( 0 < sizeOfActualPool )
15055 : {
15056 0 : SgWhereStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15057 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15058 : {
15059 0 : new SgWhereStatement ( SgWhereStatementStorageArray[i] ) ;
15060 : }
15061 0 : delete [] SgWhereStatementStorageArray;
15062 : }
15063 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWhileStmt ) ;
15064 0 : std::cout << " SgWhileStmt has size " << sizeOfActualPool << std::endl;
15065 0 : if ( 0 < sizeOfActualPool )
15066 : {
15067 0 : SgWhileStmtStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15068 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15069 : {
15070 0 : new SgWhileStmt ( SgWhileStmtStorageArray[i] ) ;
15071 : }
15072 0 : delete [] SgWhileStmtStorageArray;
15073 : }
15074 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgWriteStatement ) ;
15075 0 : std::cout << " SgWriteStatement has size " << sizeOfActualPool << std::endl;
15076 0 : if ( 0 < sizeOfActualPool )
15077 : {
15078 0 : SgWriteStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15079 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15080 : {
15081 0 : new SgWriteStatement ( SgWriteStatementStorageArray[i] ) ;
15082 : }
15083 0 : delete [] SgWriteStatementStorageArray;
15084 : }
15085 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgXorAssignOp ) ;
15086 0 : std::cout << " SgXorAssignOp has size " << sizeOfActualPool << std::endl;
15087 0 : if ( 0 < sizeOfActualPool )
15088 : {
15089 0 : SgXorAssignOpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15090 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15091 : {
15092 0 : new SgXorAssignOp ( SgXorAssignOpStorageArray[i] ) ;
15093 : }
15094 0 : delete [] SgXorAssignOpStorageArray;
15095 : }
15096 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgYieldExpression ) ;
15097 0 : std::cout << " SgYieldExpression has size " << sizeOfActualPool << std::endl;
15098 0 : if ( 0 < sizeOfActualPool )
15099 : {
15100 0 : SgYieldExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15101 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15102 : {
15103 0 : new SgYieldExpression ( SgYieldExpressionStorageArray[i] ) ;
15104 : }
15105 0 : delete [] SgYieldExpressionStorageArray;
15106 : }
15107 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_Sg_File_Info ) ;
15108 0 : std::cout << " Sg_File_Info has size " << sizeOfActualPool << std::endl;
15109 0 : if ( 0 < sizeOfActualPool )
15110 : {
15111 0 : Sg_File_InfoStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15112 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15113 : {
15114 0 : new Sg_File_Info ( Sg_File_InfoStorageArray[i] ) ;
15115 : }
15116 0 : delete [] Sg_File_InfoStorageArray;
15117 : }
15118 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeCAFTeam ) ;
15119 0 : std::cout << " SgTypeCAFTeam has size " << sizeOfActualPool << std::endl;
15120 0 : if ( 0 < sizeOfActualPool )
15121 : {
15122 0 : SgTypeCAFTeamStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15123 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15124 : {
15125 0 : new SgTypeCAFTeam ( SgTypeCAFTeamStorageArray[i] ) ;
15126 : }
15127 0 : delete [] SgTypeCAFTeamStorageArray;
15128 : }
15129 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCAFWithTeamStatement ) ;
15130 0 : std::cout << " SgCAFWithTeamStatement has size " << sizeOfActualPool << std::endl;
15131 0 : if ( 0 < sizeOfActualPool )
15132 : {
15133 0 : SgCAFWithTeamStatementStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15134 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15135 : {
15136 0 : new SgCAFWithTeamStatement ( SgCAFWithTeamStatementStorageArray[i] ) ;
15137 : }
15138 0 : delete [] SgCAFWithTeamStatementStorageArray;
15139 : }
15140 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCAFCoExpression ) ;
15141 0 : std::cout << " SgCAFCoExpression has size " << sizeOfActualPool << std::endl;
15142 0 : if ( 0 < sizeOfActualPool )
15143 : {
15144 0 : SgCAFCoExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15145 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15146 : {
15147 0 : new SgCAFCoExpression ( SgCAFCoExpressionStorageArray[i] ) ;
15148 : }
15149 0 : delete [] SgCAFCoExpressionStorageArray;
15150 : }
15151 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgCallExpression ) ;
15152 0 : std::cout << " SgCallExpression has size " << sizeOfActualPool << std::endl;
15153 0 : if ( 0 < sizeOfActualPool )
15154 : {
15155 0 : SgCallExpressionStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15156 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15157 : {
15158 0 : new SgCallExpression ( SgCallExpressionStorageArray[i] ) ;
15159 : }
15160 0 : delete [] SgCallExpressionStorageArray;
15161 : }
15162 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgTypeCrayPointer ) ;
15163 0 : std::cout << " SgTypeCrayPointer has size " << sizeOfActualPool << std::endl;
15164 0 : if ( 0 < sizeOfActualPool )
15165 : {
15166 0 : SgTypeCrayPointerStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15167 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15168 : {
15169 0 : new SgTypeCrayPointer ( SgTypeCrayPointerStorageArray[i] ) ;
15170 : }
15171 0 : delete [] SgTypeCrayPointerStorageArray;
15172 : }
15173 0 : sizeOfActualPool = getPoolSizeOfNewAst( V_SgClassExp ) ;
15174 0 : std::cout << " SgClassExp has size " << sizeOfActualPool << std::endl;
15175 0 : if ( 0 < sizeOfActualPool )
15176 : {
15177 0 : SgClassExpStorageClass :: arrangeStaticDataOfEasyStorageClassesInOneBlock () ;
15178 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
15179 : {
15180 0 : new SgClassExp ( SgClassExpStorageArray[i] ) ;
15181 : }
15182 0 : delete [] SgClassExpStorageArray;
15183 : }
15184 :
15185 : /* #line 251 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
15186 :
15187 : #if FILE_IO_EXTRA_CHECK
15188 : // DQ (4/22/2006): Added timer information for AST File I/O
15189 0 : TimingPerformance nested_timer ("AST_FILE_IO::compressAstInMemoryPool() FILE_IO_EXTRA_CHECK:");
15190 :
15191 0 : for ( int i = 0; i < totalNumberOfIRNodes; ++i)
15192 : {
15193 0 : listOfMemoryPoolSizes[i] += getPoolSizeOfNewAst(i);
15194 : }
15195 0 : listOfMemoryPoolSizes[totalNumberOfIRNodes] += getTotalNumberOfNodesOfNewAst();
15196 : // std::cout << "Starting check, that all IRNodes are in the memory pools ... " << std::flush;
15197 : #if FILE_IO_MEMORY_POOL_CHECK
15198 : // AST_FileIO::MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal;
15199 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal;
15200 : memoryCheckingTraversal.traverseMemoryPool();
15201 : #endif
15202 : // std::cout << " done ! " << std::endl;
15203 : #endif
15204 :
15205 0 : }
15206 :
15207 :
15208 : void
15209 5 : AST_FILE_IO :: resetValidAstAfterWriting ( )
15210 : {
15211 : // DQ (2/26/2010): Test this uncommented.
15212 : #if 1
15213 5 : SgAccessModifier::resetValidFreepointers( );
15214 5 : SgActualArgumentExpression::resetValidFreepointers( );
15215 5 : SgAddOp::resetValidFreepointers( );
15216 5 : SgAddressOfOp::resetValidFreepointers( );
15217 5 : SgAggregateInitializer::resetValidFreepointers( );
15218 5 : SgAliasSymbol::resetValidFreepointers( );
15219 5 : SgAllocateStatement::resetValidFreepointers( );
15220 5 : SgAndAssignOp::resetValidFreepointers( );
15221 5 : SgAndOp::resetValidFreepointers( );
15222 5 : SgArithmeticIfStatement::resetValidFreepointers( );
15223 5 : SgArrayType::resetValidFreepointers( );
15224 5 : SgArrowExp::resetValidFreepointers( );
15225 5 : SgArrowStarOp::resetValidFreepointers( );
15226 5 : SgAsmOp::resetValidFreepointers( );
15227 5 : SgAsmStmt::resetValidFreepointers( );
15228 5 : SgAssertStmt::resetValidFreepointers( );
15229 5 : SgAssignInitializer::resetValidFreepointers( );
15230 5 : SgAssignOp::resetValidFreepointers( );
15231 5 : SgAssignStatement::resetValidFreepointers( );
15232 5 : SgAssignedGotoStatement::resetValidFreepointers( );
15233 5 : SgAssociateStatement::resetValidFreepointers( );
15234 5 : SgAsteriskShapeExp::resetValidFreepointers( );
15235 5 : SgAttribute::resetValidFreepointers( );
15236 5 : SgAttributeSpecificationStatement::resetValidFreepointers( );
15237 5 : SgAutoType::resetValidFreepointers( );
15238 5 : SgAwaitExpression::resetValidFreepointers( );
15239 5 : SgBackspaceStatement::resetValidFreepointers( );
15240 5 : SgBaseClass::resetValidFreepointers( );
15241 5 : SgExpBaseClass::resetValidFreepointers( );
15242 5 : SgBaseClassModifier::resetValidFreepointers( );
15243 5 : SgBasicBlock::resetValidFreepointers( );
15244 5 : SgBidirectionalGraph::resetValidFreepointers( );
15245 5 : SgBinaryOp::resetValidFreepointers( );
15246 5 : SgBitAndOp::resetValidFreepointers( );
15247 5 : SgBitAttribute::resetValidFreepointers( );
15248 5 : SgBitComplementOp::resetValidFreepointers( );
15249 5 : SgBitEqvOp::resetValidFreepointers( );
15250 5 : SgBitOrOp::resetValidFreepointers( );
15251 5 : SgBitXorOp::resetValidFreepointers( );
15252 5 : SgBlockDataStatement::resetValidFreepointers( );
15253 5 : SgBoolValExp::resetValidFreepointers( );
15254 5 : SgBreakStmt::resetValidFreepointers( );
15255 5 : SgBracedInitializer::resetValidFreepointers( );
15256 5 : SgC_PreprocessorDirectiveStatement::resetValidFreepointers( );
15257 5 : SgCaseOptionStmt::resetValidFreepointers( );
15258 5 : SgCastExp::resetValidFreepointers( );
15259 5 : SgCatchOptionStmt::resetValidFreepointers( );
15260 5 : SgCatchStatementSeq::resetValidFreepointers( );
15261 5 : SgCharVal::resetValidFreepointers( );
15262 5 : SgChar16Val::resetValidFreepointers( );
15263 5 : SgChar32Val::resetValidFreepointers( );
15264 5 : SgChooseExpression::resetValidFreepointers( );
15265 5 : SgClassDecl_attr::resetValidFreepointers( );
15266 5 : SgClassDeclaration::resetValidFreepointers( );
15267 5 : SgClassDefinition::resetValidFreepointers( );
15268 5 : SgClassNameRefExp::resetValidFreepointers( );
15269 5 : SgClassSymbol::resetValidFreepointers( );
15270 5 : SgClassType::resetValidFreepointers( );
15271 5 : SgClinkageDeclarationStatement::resetValidFreepointers( );
15272 5 : SgClinkageEndStatement::resetValidFreepointers( );
15273 5 : SgClinkageStartStatement::resetValidFreepointers( );
15274 5 : SgCloseStatement::resetValidFreepointers( );
15275 5 : SgColonShapeExp::resetValidFreepointers( );
15276 5 : SgCommaOpExp::resetValidFreepointers( );
15277 5 : SgCommonBlock::resetValidFreepointers( );
15278 5 : SgCommonBlockObject::resetValidFreepointers( );
15279 5 : SgCommonSymbol::resetValidFreepointers( );
15280 5 : SgComplexVal::resetValidFreepointers( );
15281 5 : SgComprehension::resetValidFreepointers( );
15282 5 : SgCompoundAssignOp::resetValidFreepointers( );
15283 5 : SgCompoundInitializer::resetValidFreepointers( );
15284 5 : SgCompoundLiteralExp::resetValidFreepointers( );
15285 5 : SgComputedGotoStatement::resetValidFreepointers( );
15286 5 : SgConcatenationOp::resetValidFreepointers( );
15287 5 : SgConditionalExp::resetValidFreepointers( );
15288 5 : SgConjugateOp::resetValidFreepointers( );
15289 5 : SgConstVolatileModifier::resetValidFreepointers( );
15290 5 : SgConstructorInitializer::resetValidFreepointers( );
15291 5 : SgContainsStatement::resetValidFreepointers( );
15292 5 : SgContinueStmt::resetValidFreepointers( );
15293 5 : SgCtorInitializerList::resetValidFreepointers( );
15294 5 : SgDataStatementGroup::resetValidFreepointers( );
15295 5 : SgDataStatementObject::resetValidFreepointers( );
15296 5 : SgDataStatementValue::resetValidFreepointers( );
15297 5 : SgDeadIfDirectiveStatement::resetValidFreepointers( );
15298 5 : SgDeallocateStatement::resetValidFreepointers( );
15299 5 : SgDeclarationModifier::resetValidFreepointers( );
15300 5 : SgDeclarationScope::resetValidFreepointers( );
15301 5 : SgDeclarationStatement::resetValidFreepointers( );
15302 5 : SgDeclType::resetValidFreepointers( );
15303 5 : SgDefaultOptionStmt::resetValidFreepointers( );
15304 5 : SgDefaultSymbol::resetValidFreepointers( );
15305 5 : SgDefineDirectiveStatement::resetValidFreepointers( );
15306 5 : SgDeleteExp::resetValidFreepointers( );
15307 5 : SgDerivedTypeStatement::resetValidFreepointers( );
15308 5 : SgDesignatedInitializer::resetValidFreepointers( );
15309 5 : SgDictionaryComprehension::resetValidFreepointers( );
15310 5 : SgDictionaryExp::resetValidFreepointers( );
15311 5 : SgDimensionObject::resetValidFreepointers( );
15312 5 : SgDirectedGraphEdge::resetValidFreepointers( );
15313 5 : SgDirectory::resetValidFreepointers( );
15314 5 : SgDirectoryList::resetValidFreepointers( );
15315 5 : SgDivAssignOp::resetValidFreepointers( );
15316 5 : SgDivideOp::resetValidFreepointers( );
15317 5 : SgDoWhileStmt::resetValidFreepointers( );
15318 5 : SgDotExp::resetValidFreepointers( );
15319 5 : SgDotStarOp::resetValidFreepointers( );
15320 5 : SgDoubleVal::resetValidFreepointers( );
15321 5 : SgElaboratedTypeModifier::resetValidFreepointers( );
15322 5 : SgElementwiseOp::resetValidFreepointers( );
15323 5 : SgElementwiseAddOp::resetValidFreepointers( );
15324 5 : SgElementwiseDivideOp::resetValidFreepointers( );
15325 5 : SgElementwiseLeftDivideOp::resetValidFreepointers( );
15326 5 : SgElementwiseMultiplyOp::resetValidFreepointers( );
15327 5 : SgElementwisePowerOp::resetValidFreepointers( );
15328 5 : SgElementwiseSubtractOp::resetValidFreepointers( );
15329 5 : SgElseDirectiveStatement::resetValidFreepointers( );
15330 5 : SgElseWhereStatement::resetValidFreepointers( );
15331 5 : SgElseifDirectiveStatement::resetValidFreepointers( );
15332 5 : SgEmptyDeclaration::resetValidFreepointers( );
15333 5 : SgEmptyDirectiveStatement::resetValidFreepointers( );
15334 5 : SgEndfileStatement::resetValidFreepointers( );
15335 5 : SgEndifDirectiveStatement::resetValidFreepointers( );
15336 5 : SgEntryStatement::resetValidFreepointers( );
15337 5 : SgEnumDeclaration::resetValidFreepointers( );
15338 5 : SgEnumFieldSymbol::resetValidFreepointers( );
15339 5 : SgEnumSymbol::resetValidFreepointers( );
15340 5 : SgEnumType::resetValidFreepointers( );
15341 5 : SgEnumVal::resetValidFreepointers( );
15342 5 : SgEqualityOp::resetValidFreepointers( );
15343 5 : SgEquivalenceStatement::resetValidFreepointers( );
15344 5 : SgErrorDirectiveStatement::resetValidFreepointers( );
15345 5 : SgExecStatement::resetValidFreepointers( );
15346 5 : SgExponentiationOp::resetValidFreepointers( );
15347 5 : SgExponentiationAssignOp::resetValidFreepointers( );
15348 5 : SgExprListExp::resetValidFreepointers( );
15349 5 : SgExprStatement::resetValidFreepointers( );
15350 5 : SgExpression::resetValidFreepointers( );
15351 5 : SgExpressionRoot::resetValidFreepointers( );
15352 5 : SgFile::resetValidFreepointers( );
15353 5 : SgFileList::resetValidFreepointers( );
15354 5 : SgFloatVal::resetValidFreepointers( );
15355 5 : SgFloat128Val::resetValidFreepointers( );
15356 5 : SgFloat80Val::resetValidFreepointers( );
15357 5 : SgFoldExpression::resetValidFreepointers( );
15358 5 : SgFlushStatement::resetValidFreepointers( );
15359 5 : SgForAllStatement::resetValidFreepointers( );
15360 5 : SgForInitStatement::resetValidFreepointers( );
15361 5 : SgForStatement::resetValidFreepointers( );
15362 5 : SgFormatItem::resetValidFreepointers( );
15363 5 : SgFormatItemList::resetValidFreepointers( );
15364 5 : SgFormatStatement::resetValidFreepointers( );
15365 5 : SgFortranDo::resetValidFreepointers( );
15366 5 : SgFortranIncludeLine::resetValidFreepointers( );
15367 5 : SgFortranNonblockedDo::resetValidFreepointers( );
15368 5 : SgFuncDecl_attr::resetValidFreepointers( );
15369 5 : SgFunctionCallExp::resetValidFreepointers( );
15370 5 : SgFunctionDeclaration::resetValidFreepointers( );
15371 5 : SgFunctionDefinition::resetValidFreepointers( );
15372 5 : SgFunctionParameterScope::resetValidFreepointers( );
15373 5 : SgFunctionModifier::resetValidFreepointers( );
15374 5 : SgFunctionParameterList::resetValidFreepointers( );
15375 5 : SgFunctionParameterRefExp::resetValidFreepointers( );
15376 5 : SgFunctionParameterTypeList::resetValidFreepointers( );
15377 5 : SgFunctionRefExp::resetValidFreepointers( );
15378 5 : SgFunctionSymbol::resetValidFreepointers( );
15379 5 : SgFunctionType::resetValidFreepointers( );
15380 5 : SgFunctionTypeSymbol::resetValidFreepointers( );
15381 5 : SgFunctionTypeTable::resetValidFreepointers( );
15382 5 : SgTypeTable::resetValidFreepointers( );
15383 5 : SgGlobal::resetValidFreepointers( );
15384 5 : SgGotoStatement::resetValidFreepointers( );
15385 5 : SgGraph::resetValidFreepointers( );
15386 5 : SgGraphEdge::resetValidFreepointers( );
15387 5 : SgGraphEdgeList::resetValidFreepointers( );
15388 5 : SgGraphNode::resetValidFreepointers( );
15389 5 : SgGraphNodeList::resetValidFreepointers( );
15390 5 : SgGreaterOrEqualOp::resetValidFreepointers( );
15391 5 : SgGreaterThanOp::resetValidFreepointers( );
15392 5 : SgIOItemExpression::resetValidFreepointers( );
15393 5 : SgIOStatement::resetValidFreepointers( );
15394 5 : SgIdentDirectiveStatement::resetValidFreepointers( );
15395 5 : SgIfDirectiveStatement::resetValidFreepointers( );
15396 5 : SgIfStmt::resetValidFreepointers( );
15397 5 : SgIfdefDirectiveStatement::resetValidFreepointers( );
15398 5 : SgIfndefDirectiveStatement::resetValidFreepointers( );
15399 5 : SgImageControlStatement::resetValidFreepointers( );
15400 5 : SgImagPartOp::resetValidFreepointers( );
15401 5 : SgImplicitStatement::resetValidFreepointers( );
15402 5 : SgImpliedDo::resetValidFreepointers( );
15403 5 : SgImportStatement::resetValidFreepointers( );
15404 5 : SgIncidenceDirectedGraph::resetValidFreepointers( );
15405 5 : SgIncidenceUndirectedGraph::resetValidFreepointers( );
15406 5 : SgIncludeDirectiveStatement::resetValidFreepointers( );
15407 5 : SgIncludeFile::resetValidFreepointers( );
15408 5 : SgIncludeNextDirectiveStatement::resetValidFreepointers( );
15409 5 : SgInitializedName::resetValidFreepointers( );
15410 5 : SgInitializer::resetValidFreepointers( );
15411 5 : SgInquireStatement::resetValidFreepointers( );
15412 5 : SgIntKeyedBidirectionalGraph::resetValidFreepointers( );
15413 5 : SgIntVal::resetValidFreepointers( );
15414 5 : SgIntegerDivideOp::resetValidFreepointers( );
15415 5 : SgIntegerDivideAssignOp::resetValidFreepointers( );
15416 5 : SgInterfaceBody::resetValidFreepointers( );
15417 5 : SgHeaderFileBody::resetValidFreepointers( );
15418 5 : SgHeaderFileReport::resetValidFreepointers( );
15419 5 : SgInterfaceStatement::resetValidFreepointers( );
15420 5 : SgInterfaceSymbol::resetValidFreepointers( );
15421 5 : SgIntrinsicSymbol::resetValidFreepointers( );
15422 5 : SgIsOp::resetValidFreepointers( );
15423 5 : SgIsNotOp::resetValidFreepointers( );
15424 5 : SgIorAssignOp::resetValidFreepointers( );
15425 5 : SgKeyDatumPair::resetValidFreepointers( );
15426 5 : SgCudaKernelExecConfig::resetValidFreepointers( );
15427 5 : SgCudaKernelCallExp::resetValidFreepointers( );
15428 5 : SgLabelRefExp::resetValidFreepointers( );
15429 5 : SgLabelStatement::resetValidFreepointers( );
15430 5 : SgLabelSymbol::resetValidFreepointers( );
15431 5 : SgLambdaCapture::resetValidFreepointers( );
15432 5 : SgLambdaCaptureList::resetValidFreepointers( );
15433 5 : SgLambdaExp::resetValidFreepointers( );
15434 5 : SgLambdaRefExp::resetValidFreepointers( );
15435 5 : SgLeftDivideOp::resetValidFreepointers( );
15436 5 : SgLessOrEqualOp::resetValidFreepointers( );
15437 5 : SgLessThanOp::resetValidFreepointers( );
15438 5 : SgLineDirectiveStatement::resetValidFreepointers( );
15439 5 : SgLinemarkerDirectiveStatement::resetValidFreepointers( );
15440 5 : SgLinkageModifier::resetValidFreepointers( );
15441 5 : SgListComprehension::resetValidFreepointers( );
15442 5 : SgListExp::resetValidFreepointers( );
15443 5 : SgLocatedNode::resetValidFreepointers( );
15444 5 : SgLocatedNodeSupport::resetValidFreepointers( );
15445 5 : SgLongDoubleVal::resetValidFreepointers( );
15446 5 : SgLongIntVal::resetValidFreepointers( );
15447 5 : SgLongLongIntVal::resetValidFreepointers( );
15448 5 : SgLshiftAssignOp::resetValidFreepointers( );
15449 5 : SgLshiftOp::resetValidFreepointers( );
15450 5 : SgMagicColonExp::resetValidFreepointers( );
15451 5 : SgMatrixExp::resetValidFreepointers( );
15452 5 : SgMatrixTransposeOp::resetValidFreepointers( );
15453 5 : SgMemberFunctionDeclaration::resetValidFreepointers( );
15454 5 : SgMemberFunctionRefExp::resetValidFreepointers( );
15455 5 : SgMemberFunctionSymbol::resetValidFreepointers( );
15456 5 : SgMemberFunctionType::resetValidFreepointers( );
15457 5 : SgMembershipOp::resetValidFreepointers( );
15458 5 : SgMicrosoftAttributeDeclaration::resetValidFreepointers( );
15459 5 : SgMinusAssignOp::resetValidFreepointers( );
15460 5 : SgMinusMinusOp::resetValidFreepointers( );
15461 5 : SgMinusOp::resetValidFreepointers( );
15462 5 : SgModAssignOp::resetValidFreepointers( );
15463 5 : SgModOp::resetValidFreepointers( );
15464 5 : SgModifier::resetValidFreepointers( );
15465 5 : SgModifierNodes::resetValidFreepointers( );
15466 5 : SgModifierType::resetValidFreepointers( );
15467 5 : SgModuleStatement::resetValidFreepointers( );
15468 5 : SgModuleSymbol::resetValidFreepointers( );
15469 5 : SgMultAssignOp::resetValidFreepointers( );
15470 5 : SgMultiplyOp::resetValidFreepointers( );
15471 5 : SgName::resetValidFreepointers( );
15472 5 : SgNameGroup::resetValidFreepointers( );
15473 5 : SgNamedType::resetValidFreepointers( );
15474 5 : SgNamelistStatement::resetValidFreepointers( );
15475 5 : SgNamespaceAliasDeclarationStatement::resetValidFreepointers( );
15476 5 : SgNamespaceDeclarationStatement::resetValidFreepointers( );
15477 5 : SgNamespaceDefinitionStatement::resetValidFreepointers( );
15478 5 : SgNamespaceSymbol::resetValidFreepointers( );
15479 5 : SgNaryOp::resetValidFreepointers( );
15480 5 : SgNaryBooleanOp::resetValidFreepointers( );
15481 5 : SgNaryComparisonOp::resetValidFreepointers( );
15482 5 : SgNewExp::resetValidFreepointers( );
15483 5 : SgNode::resetValidFreepointers( );
15484 5 : SgNoexceptOp::resetValidFreepointers( );
15485 5 : SgNotEqualOp::resetValidFreepointers( );
15486 5 : SgNotOp::resetValidFreepointers( );
15487 5 : SgNonMembershipOp::resetValidFreepointers( );
15488 5 : SgNonrealDecl::resetValidFreepointers( );
15489 5 : SgNonrealRefExp::resetValidFreepointers( );
15490 5 : SgNonrealSymbol::resetValidFreepointers( );
15491 5 : SgNonrealType::resetValidFreepointers( );
15492 5 : SgNonrealBaseClass::resetValidFreepointers( );
15493 5 : SgNullExpression::resetValidFreepointers( );
15494 5 : SgNullptrValExp::resetValidFreepointers( );
15495 5 : SgNullStatement::resetValidFreepointers( );
15496 5 : SgNullifyStatement::resetValidFreepointers( );
15497 5 : SgOmpAtomicStatement::resetValidFreepointers( );
15498 5 : SgOmpBarrierStatement::resetValidFreepointers( );
15499 5 : SgOmpCriticalStatement::resetValidFreepointers( );
15500 5 : SgUpirFieldBodyStatement::resetValidFreepointers( );
15501 5 : SgUpirBodyStatement::resetValidFreepointers( );
15502 5 : SgUpirFieldStatement::resetValidFreepointers( );
15503 5 : SgOmpDoStatement::resetValidFreepointers( );
15504 5 : SgOmpFlushStatement::resetValidFreepointers( );
15505 5 : SgOmpAllocateStatement::resetValidFreepointers( );
15506 5 : SgOmpDeclareSimdStatement::resetValidFreepointers( );
15507 5 : SgUpirWorksharingStatement::resetValidFreepointers( );
15508 5 : SgOmpForSimdStatement::resetValidFreepointers( );
15509 5 : SgOmpMasterStatement::resetValidFreepointers( );
15510 5 : SgOmpTaskyieldStatement::resetValidFreepointers( );
15511 5 : SgOmpMetadirectiveStatement::resetValidFreepointers( );
15512 5 : SgOmpOrderedStatement::resetValidFreepointers( );
15513 5 : SgOmpOrderedDependStatement::resetValidFreepointers( );
15514 5 : SgUpirSpmdStatement::resetValidFreepointers( );
15515 5 : SgOmpTeamsStatement::resetValidFreepointers( );
15516 5 : SgOmpCancellationPointStatement::resetValidFreepointers( );
15517 5 : SgOmpDeclareMapperStatement::resetValidFreepointers( );
15518 5 : SgOmpCancelStatement::resetValidFreepointers( );
15519 5 : SgOmpTaskgroupStatement::resetValidFreepointers( );
15520 5 : SgOmpDepobjStatement::resetValidFreepointers( );
15521 5 : SgOmpDistributeStatement::resetValidFreepointers( );
15522 5 : SgOmpLoopStatement::resetValidFreepointers( );
15523 5 : SgOmpScanStatement::resetValidFreepointers( );
15524 5 : SgOmpTaskloopStatement::resetValidFreepointers( );
15525 5 : SgOmpTargetEnterDataStatement::resetValidFreepointers( );
15526 5 : SgOmpTargetExitDataStatement::resetValidFreepointers( );
15527 5 : SgOmpSectionStatement::resetValidFreepointers( );
15528 5 : SgOmpSectionsStatement::resetValidFreepointers( );
15529 5 : SgOmpSingleStatement::resetValidFreepointers( );
15530 5 : SgOmpTaskStatement::resetValidFreepointers( );
15531 5 : SgOmpTaskwaitStatement::resetValidFreepointers( );
15532 5 : SgOmpThreadprivateStatement::resetValidFreepointers( );
15533 5 : SgOmpWorkshareStatement::resetValidFreepointers( );
15534 5 : SgUpirTaskStatement::resetValidFreepointers( );
15535 5 : SgOmpTargetDataStatement::resetValidFreepointers( );
15536 5 : SgOmpTargetParallelForStatement::resetValidFreepointers( );
15537 5 : SgOmpTargetUpdateStatement::resetValidFreepointers( );
15538 5 : SgOmpRequiresStatement::resetValidFreepointers( );
15539 5 : SgOmpTargetParallelStatement::resetValidFreepointers( );
15540 5 : SgOmpTargetParallelForSimdStatement::resetValidFreepointers( );
15541 5 : SgOmpTargetParallelLoopStatement::resetValidFreepointers( );
15542 5 : SgOmpTargetSimdStatement::resetValidFreepointers( );
15543 5 : SgOmpTargetTeamsStatement::resetValidFreepointers( );
15544 5 : SgOmpTargetTeamsDistributeStatement::resetValidFreepointers( );
15545 5 : SgOmpTargetTeamsDistributeSimdStatement::resetValidFreepointers( );
15546 5 : SgOmpTargetTeamsLoopStatement::resetValidFreepointers( );
15547 5 : SgOmpTargetTeamsDistributeParallelForStatement::resetValidFreepointers( );
15548 5 : SgOmpTargetTeamsDistributeParallelForSimdStatement::resetValidFreepointers( );
15549 5 : SgOmpDistributeSimdStatement::resetValidFreepointers( );
15550 5 : SgOmpDistributeParallelForStatement::resetValidFreepointers( );
15551 5 : SgOmpDistributeParallelForSimdStatement::resetValidFreepointers( );
15552 5 : SgOmpTaskloopSimdStatement::resetValidFreepointers( );
15553 5 : SgOmpMasterTaskloopSimdStatement::resetValidFreepointers( );
15554 5 : SgOmpParallelMasterTaskloopStatement::resetValidFreepointers( );
15555 5 : SgOmpParallelMasterTaskloopSimdStatement::resetValidFreepointers( );
15556 5 : SgOmpTeamsDistributeStatement::resetValidFreepointers( );
15557 5 : SgOmpTeamsDistributeSimdStatement::resetValidFreepointers( );
15558 5 : SgOmpTeamsDistributeParallelForStatement::resetValidFreepointers( );
15559 5 : SgOmpTeamsDistributeParallelForSimdStatement::resetValidFreepointers( );
15560 5 : SgOmpTeamsLoopStatement::resetValidFreepointers( );
15561 5 : SgOmpParallelLoopStatement::resetValidFreepointers( );
15562 5 : SgOmpParallelMasterStatement::resetValidFreepointers( );
15563 5 : SgOmpMasterTaskloopStatement::resetValidFreepointers( );
15564 5 : SgOmpUnrollStatement::resetValidFreepointers( );
15565 5 : SgOmpTileStatement::resetValidFreepointers( );
15566 5 : SgUpirSimdStatement::resetValidFreepointers( );
15567 5 : SgUpirBaseStatement::resetValidFreepointers( );
15568 5 : SgUpirLoopStatement::resetValidFreepointers( );
15569 5 : SgUpirLoopParallelStatement::resetValidFreepointers( );
15570 5 : SgUpirSyncStatement::resetValidFreepointers( );
15571 5 : SgOmpClause::resetValidFreepointers( );
15572 5 : SgOmpAllocateClause::resetValidFreepointers( );
15573 5 : SgOmpAllocatorClause::resetValidFreepointers( );
15574 5 : SgOmpUsesAllocatorsClause::resetValidFreepointers( );
15575 5 : SgOmpUsesAllocatorsDefination::resetValidFreepointers( );
15576 5 : SgOmpToClause::resetValidFreepointers( );
15577 5 : SgOmpFromClause::resetValidFreepointers( );
15578 5 : SgOmpThreadsClause::resetValidFreepointers( );
15579 5 : SgOmpSimdClause::resetValidFreepointers( );
15580 5 : SgOmpBeginClause::resetValidFreepointers( );
15581 5 : SgOmpCollapseClause::resetValidFreepointers( );
15582 5 : SgOmpCopyinClause::resetValidFreepointers( );
15583 5 : SgOmpCopyprivateClause::resetValidFreepointers( );
15584 5 : SgOmpDefaultClause::resetValidFreepointers( );
15585 5 : SgOmpEndClause::resetValidFreepointers( );
15586 5 : SgOmpExpressionClause::resetValidFreepointers( );
15587 5 : SgOmpFirstprivateClause::resetValidFreepointers( );
15588 5 : SgOmpIfClause::resetValidFreepointers( );
15589 5 : SgOmpFinalClause::resetValidFreepointers( );
15590 5 : SgOmpPriorityClause::resetValidFreepointers( );
15591 5 : SgOmpDeviceClause::resetValidFreepointers( );
15592 5 : SgOmpLastprivateClause::resetValidFreepointers( );
15593 5 : SgOmpNowaitClause::resetValidFreepointers( );
15594 5 : SgOmpReadClause::resetValidFreepointers( );
15595 5 : SgOmpWriteClause::resetValidFreepointers( );
15596 5 : SgOmpUpdateClause::resetValidFreepointers( );
15597 5 : SgOmpDepobjUpdateClause::resetValidFreepointers( );
15598 5 : SgOmpDestroyClause::resetValidFreepointers( );
15599 5 : SgOmpCaptureClause::resetValidFreepointers( );
15600 5 : SgOmpSeqCstClause::resetValidFreepointers( );
15601 5 : SgOmpAcqRelClause::resetValidFreepointers( );
15602 5 : SgOmpReleaseClause::resetValidFreepointers( );
15603 5 : SgOmpAcquireClause::resetValidFreepointers( );
15604 5 : SgOmpReverseOffloadClause::resetValidFreepointers( );
15605 5 : SgOmpUnifiedAddressClause::resetValidFreepointers( );
15606 5 : SgOmpUnifiedSharedMemoryClause::resetValidFreepointers( );
15607 5 : SgOmpDynamicAllocatorsClause::resetValidFreepointers( );
15608 5 : SgOmpAtomicDefaultMemOrderClause::resetValidFreepointers( );
15609 5 : SgOmpExtImplementationDefinedRequirementClause::resetValidFreepointers( );
15610 5 : SgOmpRelaxedClause::resetValidFreepointers( );
15611 5 : SgOmpParallelClause::resetValidFreepointers( );
15612 5 : SgOmpSectionsClause::resetValidFreepointers( );
15613 5 : SgOmpForClause::resetValidFreepointers( );
15614 5 : SgOmpTaskgroupClause::resetValidFreepointers( );
15615 5 : SgUpirNumUnitsField::resetValidFreepointers( );
15616 5 : SgOmpNumTeamsClause::resetValidFreepointers( );
15617 5 : SgOmpGrainsizeClause::resetValidFreepointers( );
15618 5 : SgOmpDetachClause::resetValidFreepointers( );
15619 5 : SgOmpNumTasksClause::resetValidFreepointers( );
15620 5 : SgOmpNogroupClause::resetValidFreepointers( );
15621 5 : SgOmpHintClause::resetValidFreepointers( );
15622 5 : SgOmpOrderClause::resetValidFreepointers( );
15623 5 : SgOmpDistScheduleClause::resetValidFreepointers( );
15624 5 : SgOmpBindClause::resetValidFreepointers( );
15625 5 : SgOmpNontemporalClause::resetValidFreepointers( );
15626 5 : SgOmpInclusiveClause::resetValidFreepointers( );
15627 5 : SgOmpExclusiveClause::resetValidFreepointers( );
15628 5 : SgOmpIsDevicePtrClause::resetValidFreepointers( );
15629 5 : SgOmpUseDevicePtrClause::resetValidFreepointers( );
15630 5 : SgOmpUseDeviceAddrClause::resetValidFreepointers( );
15631 5 : SgOmpThreadLimitClause::resetValidFreepointers( );
15632 5 : SgOmpOrderedClause::resetValidFreepointers( );
15633 5 : SgOmpPrivateClause::resetValidFreepointers( );
15634 5 : SgOmpReductionClause::resetValidFreepointers( );
15635 5 : SgOmpInReductionClause::resetValidFreepointers( );
15636 5 : SgOmpTaskReductionClause::resetValidFreepointers( );
15637 5 : SgOmpDefaultmapClause::resetValidFreepointers( );
15638 5 : SgOmpScheduleClause::resetValidFreepointers( );
15639 5 : SgOmpSharedClause::resetValidFreepointers( );
15640 5 : SgOmpUntiedClause::resetValidFreepointers( );
15641 5 : SgOmpMergeableClause::resetValidFreepointers( );
15642 5 : SgOmpVariablesClause::resetValidFreepointers( );
15643 5 : SgOmpMapClause::resetValidFreepointers( );
15644 5 : SgOmpSafelenClause::resetValidFreepointers( );
15645 5 : SgOmpSimdlenClause::resetValidFreepointers( );
15646 5 : SgOmpLinearClause::resetValidFreepointers( );
15647 5 : SgOmpUniformClause::resetValidFreepointers( );
15648 5 : SgOmpAlignedClause::resetValidFreepointers( );
15649 5 : SgOmpProcBindClause::resetValidFreepointers( );
15650 5 : SgOmpAtomicClause::resetValidFreepointers( );
15651 5 : SgOmpInbranchClause::resetValidFreepointers( );
15652 5 : SgOmpNotinbranchClause::resetValidFreepointers( );
15653 5 : SgOmpDependClause::resetValidFreepointers( );
15654 5 : SgOmpAffinityClause::resetValidFreepointers( );
15655 5 : SgOmpWhenClause::resetValidFreepointers( );
15656 5 : SgOmpFullClause::resetValidFreepointers( );
15657 5 : SgOmpPartialClause::resetValidFreepointers( );
15658 5 : SgOmpSizesClause::resetValidFreepointers( );
15659 5 : SgUpirBranchField::resetValidFreepointers( );
15660 5 : SgUpirNestedLevelField::resetValidFreepointers( );
15661 5 : SgUpirNestedParentField::resetValidFreepointers( );
15662 5 : SgUpirNestedChildField::resetValidFreepointers( );
15663 5 : SgUpirSyncField::resetValidFreepointers( );
15664 5 : SgUpirDataField::resetValidFreepointers( );
15665 5 : SgUpirDataItemField::resetValidFreepointers( );
15666 5 : SgUpirTargetField::resetValidFreepointers( );
15667 5 : SgOpenclAccessModeModifier::resetValidFreepointers( );
15668 5 : SgOpenStatement::resetValidFreepointers( );
15669 5 : SgOptions::resetValidFreepointers( );
15670 5 : SgOrOp::resetValidFreepointers( );
15671 5 : SgParameterStatement::resetValidFreepointers( );
15672 5 : SgPartialFunctionModifierType::resetValidFreepointers( );
15673 5 : SgPartialFunctionType::resetValidFreepointers( );
15674 5 : SgPassStatement::resetValidFreepointers( );
15675 5 : SgPlusAssignOp::resetValidFreepointers( );
15676 5 : SgPlusPlusOp::resetValidFreepointers( );
15677 5 : SgPntrArrRefExp::resetValidFreepointers( );
15678 5 : SgPointerAssignOp::resetValidFreepointers( );
15679 5 : SgPointerDerefExp::resetValidFreepointers( );
15680 5 : SgPointerMemberType::resetValidFreepointers( );
15681 5 : SgPointerType::resetValidFreepointers( );
15682 5 : SgPowerOp::resetValidFreepointers( );
15683 5 : SgPragma::resetValidFreepointers( );
15684 5 : SgPragmaDeclaration::resetValidFreepointers( );
15685 5 : SgPrintStatement::resetValidFreepointers( );
15686 5 : SgProcedureHeaderStatement::resetValidFreepointers( );
15687 5 : SgProgramHeaderStatement::resetValidFreepointers( );
15688 5 : SgProject::resetValidFreepointers( );
15689 5 : SgPseudoDestructorRefExp::resetValidFreepointers( );
15690 5 : SgQualifiedName::resetValidFreepointers( );
15691 5 : SgQualifiedNameType::resetValidFreepointers( );
15692 5 : SgRangeExp::resetValidFreepointers( );
15693 5 : SgRangeBasedForStatement::resetValidFreepointers( );
15694 5 : SgReadStatement::resetValidFreepointers( );
15695 5 : SgRealPartOp::resetValidFreepointers( );
15696 5 : SgRefExp::resetValidFreepointers( );
15697 5 : SgReferenceType::resetValidFreepointers( );
15698 5 : SgRenamePair::resetValidFreepointers( );
15699 5 : SgRenameSymbol::resetValidFreepointers( );
15700 5 : SgReturnStmt::resetValidFreepointers( );
15701 5 : SgRewindStatement::resetValidFreepointers( );
15702 5 : SgRshiftAssignOp::resetValidFreepointers( );
15703 5 : SgRshiftOp::resetValidFreepointers( );
15704 5 : SgRvalueReferenceType::resetValidFreepointers( );
15705 5 : SgScopeOp::resetValidFreepointers( );
15706 5 : SgScopeStatement::resetValidFreepointers( );
15707 5 : SgSequenceStatement::resetValidFreepointers( );
15708 5 : SgSetComprehension::resetValidFreepointers( );
15709 5 : SgShortVal::resetValidFreepointers( );
15710 5 : SgSIMDBinaryOp::resetValidFreepointers( );
15711 5 : SgSIMDAddOp::resetValidFreepointers( );
15712 5 : SgSIMDSubOp::resetValidFreepointers( );
15713 5 : SgSIMDMulOp::resetValidFreepointers( );
15714 5 : SgSIMDDivOp::resetValidFreepointers( );
15715 5 : SgSIMDFmaOp::resetValidFreepointers( );
15716 5 : SgSIMDLoad::resetValidFreepointers( );
15717 5 : SgSIMDBroadcast::resetValidFreepointers( );
15718 5 : SgSIMDStore::resetValidFreepointers( );
15719 5 : SgSIMDPartialStore::resetValidFreepointers( );
15720 5 : SgSIMDScalarStore::resetValidFreepointers( );
15721 5 : SgSIMDGather::resetValidFreepointers( );
15722 5 : SgSIMDExplicitGather::resetValidFreepointers( );
15723 5 : SgSIMDScatter::resetValidFreepointers( );
15724 5 : SgSizeOfOp::resetValidFreepointers( );
15725 5 : SgAlignOfOp::resetValidFreepointers( );
15726 5 : SgSourceFile::resetValidFreepointers( );
15727 5 : SgSpaceshipOp::resetValidFreepointers( );
15728 5 : SgSpawnStmt::resetValidFreepointers( );
15729 5 : SgSyncAllStatement::resetValidFreepointers( );
15730 5 : SgSyncImagesStatement::resetValidFreepointers( );
15731 5 : SgSyncMemoryStatement::resetValidFreepointers( );
15732 5 : SgSyncTeamStatement::resetValidFreepointers( );
15733 5 : SgLockStatement::resetValidFreepointers( );
15734 5 : SgUnlockStatement::resetValidFreepointers( );
15735 5 : SgProcessControlStatement::resetValidFreepointers( );
15736 5 : SgSpecialFunctionModifier::resetValidFreepointers( );
15737 5 : SgStatement::resetValidFreepointers( );
15738 5 : SgStaticAssertionDeclaration::resetValidFreepointers( );
15739 5 : SgStmtDeclarationStatement::resetValidFreepointers( );
15740 5 : SgStatementExpression::resetValidFreepointers( );
15741 5 : SgStatementFunctionStatement::resetValidFreepointers( );
15742 5 : SgStorageModifier::resetValidFreepointers( );
15743 5 : SgStringConversion::resetValidFreepointers( );
15744 5 : SgStringKeyedBidirectionalGraph::resetValidFreepointers( );
15745 5 : SgStringVal::resetValidFreepointers( );
15746 5 : SgStructureModifier::resetValidFreepointers( );
15747 5 : SgSubscriptExpression::resetValidFreepointers( );
15748 5 : SgSubtractOp::resetValidFreepointers( );
15749 5 : SgSupport::resetValidFreepointers( );
15750 5 : SgSwitchStatement::resetValidFreepointers( );
15751 5 : SgSymbol::resetValidFreepointers( );
15752 5 : SgSymbolTable::resetValidFreepointers( );
15753 5 : SgTemplateArgument::resetValidFreepointers( );
15754 5 : SgTemplateArgumentList::resetValidFreepointers( );
15755 5 : SgTemplateDeclaration::resetValidFreepointers( );
15756 5 : SgTemplateClassDeclaration::resetValidFreepointers( );
15757 5 : SgTemplateClassSymbol::resetValidFreepointers( );
15758 5 : SgTemplateFunctionDeclaration::resetValidFreepointers( );
15759 5 : SgTemplateFunctionRefExp::resetValidFreepointers( );
15760 5 : SgTemplateFunctionSymbol::resetValidFreepointers( );
15761 5 : SgTemplateMemberFunctionDeclaration::resetValidFreepointers( );
15762 5 : SgTemplateMemberFunctionRefExp::resetValidFreepointers( );
15763 5 : SgTemplateMemberFunctionSymbol::resetValidFreepointers( );
15764 5 : SgTemplateTypedefDeclaration::resetValidFreepointers( );
15765 5 : SgTemplateTypedefSymbol::resetValidFreepointers( );
15766 5 : SgTemplateVariableDeclaration::resetValidFreepointers( );
15767 5 : SgTemplateVariableSymbol::resetValidFreepointers( );
15768 5 : SgTemplateClassDefinition::resetValidFreepointers( );
15769 5 : SgTemplateFunctionDefinition::resetValidFreepointers( );
15770 5 : SgTemplateInstantiationDecl::resetValidFreepointers( );
15771 5 : SgTemplateInstantiationDefn::resetValidFreepointers( );
15772 5 : SgTemplateInstantiationDirectiveStatement::resetValidFreepointers( );
15773 5 : SgTemplateInstantiationFunctionDecl::resetValidFreepointers( );
15774 5 : SgTemplateInstantiationMemberFunctionDecl::resetValidFreepointers( );
15775 5 : SgTemplateInstantiationTypedefDeclaration::resetValidFreepointers( );
15776 5 : SgTemplateParameter::resetValidFreepointers( );
15777 5 : SgTemplateParameterVal::resetValidFreepointers( );
15778 5 : SgTemplateParameterList::resetValidFreepointers( );
15779 5 : SgTemplateSymbol::resetValidFreepointers( );
15780 5 : SgTemplateType::resetValidFreepointers( );
15781 5 : SgThisExp::resetValidFreepointers( );
15782 5 : SgTypeTraitBuiltinOperator::resetValidFreepointers( );
15783 5 : SgSuperExp::resetValidFreepointers( );
15784 5 : SgThrowOp::resetValidFreepointers( );
15785 5 : SgToken::resetValidFreepointers( );
15786 5 : SgTryStmt::resetValidFreepointers( );
15787 5 : SgTupleExp::resetValidFreepointers( );
15788 5 : SgType::resetValidFreepointers( );
15789 5 : SgTypeBool::resetValidFreepointers( );
15790 5 : SgTypeChar::resetValidFreepointers( );
15791 5 : SgTypeChar16::resetValidFreepointers( );
15792 5 : SgTypeChar32::resetValidFreepointers( );
15793 5 : SgTypeComplex::resetValidFreepointers( );
15794 5 : SgTypeDefault::resetValidFreepointers( );
15795 5 : SgTypeExpression::resetValidFreepointers( );
15796 5 : SgTypeLabel::resetValidFreepointers( );
15797 5 : SgTypeDouble::resetValidFreepointers( );
15798 5 : SgTypeEllipse::resetValidFreepointers( );
15799 5 : SgTypeFixed::resetValidFreepointers( );
15800 5 : SgTypeFloat::resetValidFreepointers( );
15801 5 : SgTypeFloat128::resetValidFreepointers( );
15802 5 : SgTypeFloat80::resetValidFreepointers( );
15803 5 : SgTypeGlobalVoid::resetValidFreepointers( );
15804 5 : SgTypeIdOp::resetValidFreepointers( );
15805 5 : SgTypeImaginary::resetValidFreepointers( );
15806 5 : SgTypeInt::resetValidFreepointers( );
15807 5 : SgTypeLong::resetValidFreepointers( );
15808 5 : SgTypeLongDouble::resetValidFreepointers( );
15809 5 : SgTypeLongLong::resetValidFreepointers( );
15810 5 : SgTypeModifier::resetValidFreepointers( );
15811 5 : SgTypeMatrix::resetValidFreepointers( );
15812 5 : SgTypeTuple::resetValidFreepointers( );
15813 5 : SgTypeNullptr::resetValidFreepointers( );
15814 5 : SgTypeOfType::resetValidFreepointers( );
15815 5 : SgTypeShort::resetValidFreepointers( );
15816 5 : SgTypeSigned128bitInteger::resetValidFreepointers( );
15817 5 : SgTypeSignedChar::resetValidFreepointers( );
15818 5 : SgTypeSignedInt::resetValidFreepointers( );
15819 5 : SgTypeSignedLong::resetValidFreepointers( );
15820 5 : SgTypeSignedLongLong::resetValidFreepointers( );
15821 5 : SgTypeSignedShort::resetValidFreepointers( );
15822 5 : SgTypeString::resetValidFreepointers( );
15823 5 : SgTypeUnknown::resetValidFreepointers( );
15824 5 : SgTypeUnsigned128bitInteger::resetValidFreepointers( );
15825 5 : SgTypeUnsignedChar::resetValidFreepointers( );
15826 5 : SgTypeUnsignedInt::resetValidFreepointers( );
15827 5 : SgTypeUnsignedLong::resetValidFreepointers( );
15828 5 : SgTypeUnsignedLongLong::resetValidFreepointers( );
15829 5 : SgTypeUnsignedShort::resetValidFreepointers( );
15830 5 : SgTypeVoid::resetValidFreepointers( );
15831 5 : SgTypeWchar::resetValidFreepointers( );
15832 5 : SgTypedefDeclaration::resetValidFreepointers( );
15833 5 : SgTypedefSeq::resetValidFreepointers( );
15834 5 : SgTypedefSymbol::resetValidFreepointers( );
15835 5 : SgTypedefType::resetValidFreepointers( );
15836 5 : SgUPC_AccessModifier::resetValidFreepointers( );
15837 5 : SgUnaryAddOp::resetValidFreepointers( );
15838 5 : SgUnaryOp::resetValidFreepointers( );
15839 5 : SgUndefDirectiveStatement::resetValidFreepointers( );
15840 5 : SgUndirectedGraphEdge::resetValidFreepointers( );
15841 5 : SgUnknownArrayOrFunctionReference::resetValidFreepointers( );
15842 5 : SgUnknownFile::resetValidFreepointers( );
15843 5 : SgUnparse_Info::resetValidFreepointers( );
15844 5 : SgUnsignedCharVal::resetValidFreepointers( );
15845 5 : SgUnsignedIntVal::resetValidFreepointers( );
15846 5 : SgUnsignedLongLongIntVal::resetValidFreepointers( );
15847 5 : SgUnsignedLongVal::resetValidFreepointers( );
15848 5 : SgUnsignedShortVal::resetValidFreepointers( );
15849 5 : SgUpcBarrierStatement::resetValidFreepointers( );
15850 5 : SgUpcBlocksizeofExpression::resetValidFreepointers( );
15851 5 : SgUpcElemsizeofExpression::resetValidFreepointers( );
15852 5 : SgUpcFenceStatement::resetValidFreepointers( );
15853 5 : SgUpcForAllStatement::resetValidFreepointers( );
15854 5 : SgUpcLocalsizeofExpression::resetValidFreepointers( );
15855 5 : SgUpcMythread::resetValidFreepointers( );
15856 5 : SgUpcNotifyStatement::resetValidFreepointers( );
15857 5 : SgUpcThreads::resetValidFreepointers( );
15858 5 : SgUpcWaitStatement::resetValidFreepointers( );
15859 5 : SgUseStatement::resetValidFreepointers( );
15860 5 : SgUserDefinedBinaryOp::resetValidFreepointers( );
15861 5 : SgUserDefinedUnaryOp::resetValidFreepointers( );
15862 5 : SgUsingDeclarationStatement::resetValidFreepointers( );
15863 5 : SgUsingDirectiveStatement::resetValidFreepointers( );
15864 5 : SgValueExp::resetValidFreepointers( );
15865 5 : SgVarArgCopyOp::resetValidFreepointers( );
15866 5 : SgVarArgEndOp::resetValidFreepointers( );
15867 5 : SgVarArgOp::resetValidFreepointers( );
15868 5 : SgVarArgStartOneOperandOp::resetValidFreepointers( );
15869 5 : SgVarArgStartOp::resetValidFreepointers( );
15870 5 : SgVarRefExp::resetValidFreepointers( );
15871 5 : SgVariableDeclaration::resetValidFreepointers( );
15872 5 : SgVariableDefinition::resetValidFreepointers( );
15873 5 : SgVariableSymbol::resetValidFreepointers( );
15874 5 : SgVariantExpression::resetValidFreepointers( );
15875 5 : SgVariantStatement::resetValidFreepointers( );
15876 5 : SgVoidVal::resetValidFreepointers( );
15877 5 : SgWaitStatement::resetValidFreepointers( );
15878 5 : SgWarningDirectiveStatement::resetValidFreepointers( );
15879 5 : SgWithStatement::resetValidFreepointers( );
15880 5 : SgWcharVal::resetValidFreepointers( );
15881 5 : SgWhereStatement::resetValidFreepointers( );
15882 5 : SgWhileStmt::resetValidFreepointers( );
15883 5 : SgWriteStatement::resetValidFreepointers( );
15884 5 : SgXorAssignOp::resetValidFreepointers( );
15885 5 : SgYieldExpression::resetValidFreepointers( );
15886 5 : Sg_File_Info::resetValidFreepointers( );
15887 5 : SgTypeCAFTeam::resetValidFreepointers( );
15888 5 : SgCAFWithTeamStatement::resetValidFreepointers( );
15889 5 : SgCAFCoExpression::resetValidFreepointers( );
15890 5 : SgCallExpression::resetValidFreepointers( );
15891 5 : SgTypeCrayPointer::resetValidFreepointers( );
15892 5 : SgClassExp::resetValidFreepointers( );
15893 :
15894 : /* #line 279 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
15895 : #endif
15896 5 : freepointersOfCurrentAstAreSetToGlobalIndices = false;
15897 5 : }
15898 :
15899 :
15900 : bool
15901 6800 : AST_FILE_IO :: areFreepointersContainingGlobalIndices ( )
15902 : {
15903 6800 : return freepointersOfCurrentAstAreSetToGlobalIndices;
15904 : }
15905 :
15906 : #define DEBUG_AstFileIO_getGlobalIndexFromSgClassPointer 0
15907 :
15908 3384160 : unsigned long AST_FILE_IO::getGlobalIndexFromSgClassPointer(SgNode * pointer) {
15909 3384160 : if (pointer == nullptr) return 0;
15910 :
15911 1739720 : ROSE_ASSERT(freepointersOfCurrentAstAreSetToGlobalIndices);
15912 : #if DEBUG_AstFileIO_getGlobalIndexFromSgClassPointer
15913 : printf ("In AST_FILE_IO::getGlobalIndexFromSgClassPointer():\n");
15914 : printf (" pointer = %p = %s \n", pointer, pointer ? pointer->class_name().c_str() : "");
15915 : printf (" pointer->p_freepointer = %p \n", pointer ? pointer->p_freepointer : nullptr);
15916 : #endif
15917 : //ROSE_ASSERT(pointer->p_freepointer != nullptr);
15918 1739720 : ROSE_ASSERT(pointer->p_freepointer != AST_FileIO::IS_VALID_POINTER());
15919 :
15920 1739720 : unsigned long globalIndex = (unsigned long) (pointer->p_freepointer);
15921 : #if DEBUG_AstFileIO_getGlobalIndexFromSgClassPointer
15922 : printf (" globalIndex = %zd \n", globalIndex);
15923 : #endif
15924 1739720 : return globalIndex;
15925 : }
15926 :
15927 : #define DEBUG_AstFileIO_getSgClassPointerFromGlobalIndex 0
15928 :
15929 3383890 : SgNode * AST_FILE_IO :: getSgClassPointerFromGlobalIndex ( unsigned long globalIndex ) {
15930 3383890 : if (globalIndex == 0) return nullptr;
15931 :
15932 : #if DEBUG_AstFileIO_getGlobalIndexFromSgClassPointer
15933 : printf ("In AST_FILE_IO::getSgClassPointerFromGlobalIndex():\n");
15934 : printf (" globalIndex = %zd \n", globalIndex);
15935 : #endif
15936 :
15937 1739590 : ROSE_ASSERT(!freepointersOfCurrentAstAreSetToGlobalIndices);
15938 1739590 : ROSE_ASSERT( globalIndex < getTotalNumberOfNodesOfAstInMemoryPool() + getTotalNumberOfNodesOfNewAst() );
15939 :
15940 1739590 : SgNode* returnPointer = NULL;
15941 :
15942 1739590 : if ( 0 < globalIndex )
15943 : {
15944 1739590 : unsigned long sgVariantOfIRNodeTypeOfIndex = binarySearch ( globalIndex );
15945 : #if FILE_IO_EXTRA_CHECK
15946 : // Check, wheather the index is really within the range of this memory pool
15947 1739590 : assert ( getAccumulatedPoolSizeOfNewAst(sgVariantOfIRNodeTypeOfIndex) <= globalIndex );
15948 1739590 : assert ( globalIndex < AST_FILE_IO::getAccumulatedPoolSizeOfNewAst(sgVariantOfIRNodeTypeOfIndex+1) );
15949 : #endif
15950 1739590 : switch ( sgVariantOfIRNodeTypeOfIndex )
15951 : {
15952 0 : case V_SgAccessModifier:
15953 0 : returnPointer = SgAccessModifier::getPointerFromGlobalIndex( globalIndex ) ;
15954 0 : break ;
15955 0 : case V_SgActualArgumentExpression:
15956 0 : returnPointer = SgActualArgumentExpression::getPointerFromGlobalIndex( globalIndex ) ;
15957 0 : break ;
15958 1140 : case V_SgAddOp:
15959 1140 : returnPointer = SgAddOp::getPointerFromGlobalIndex( globalIndex ) ;
15960 1140 : break ;
15961 420 : case V_SgAddressOfOp:
15962 420 : returnPointer = SgAddressOfOp::getPointerFromGlobalIndex( globalIndex ) ;
15963 420 : break ;
15964 15 : case V_SgAggregateInitializer:
15965 15 : returnPointer = SgAggregateInitializer::getPointerFromGlobalIndex( globalIndex ) ;
15966 15 : break ;
15967 13198 : case V_SgAliasSymbol:
15968 13198 : returnPointer = SgAliasSymbol::getPointerFromGlobalIndex( globalIndex ) ;
15969 13198 : break ;
15970 0 : case V_SgAllocateStatement:
15971 0 : returnPointer = SgAllocateStatement::getPointerFromGlobalIndex( globalIndex ) ;
15972 0 : break ;
15973 0 : case V_SgAndAssignOp:
15974 0 : returnPointer = SgAndAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
15975 0 : break ;
15976 1038 : case V_SgAndOp:
15977 1038 : returnPointer = SgAndOp::getPointerFromGlobalIndex( globalIndex ) ;
15978 1038 : break ;
15979 0 : case V_SgArithmeticIfStatement:
15980 0 : returnPointer = SgArithmeticIfStatement::getPointerFromGlobalIndex( globalIndex ) ;
15981 0 : break ;
15982 347 : case V_SgArrayType:
15983 347 : returnPointer = SgArrayType::getPointerFromGlobalIndex( globalIndex ) ;
15984 347 : break ;
15985 7524 : case V_SgArrowExp:
15986 7524 : returnPointer = SgArrowExp::getPointerFromGlobalIndex( globalIndex ) ;
15987 7524 : break ;
15988 24 : case V_SgArrowStarOp:
15989 24 : returnPointer = SgArrowStarOp::getPointerFromGlobalIndex( globalIndex ) ;
15990 24 : break ;
15991 0 : case V_SgAsmOp:
15992 0 : returnPointer = SgAsmOp::getPointerFromGlobalIndex( globalIndex ) ;
15993 0 : break ;
15994 0 : case V_SgAsmStmt:
15995 0 : returnPointer = SgAsmStmt::getPointerFromGlobalIndex( globalIndex ) ;
15996 0 : break ;
15997 0 : case V_SgAssertStmt:
15998 0 : returnPointer = SgAssertStmt::getPointerFromGlobalIndex( globalIndex ) ;
15999 0 : break ;
16000 5965 : case V_SgAssignInitializer:
16001 5965 : returnPointer = SgAssignInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16002 5965 : break ;
16003 2730 : case V_SgAssignOp:
16004 2730 : returnPointer = SgAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16005 2730 : break ;
16006 0 : case V_SgAssignStatement:
16007 0 : returnPointer = SgAssignStatement::getPointerFromGlobalIndex( globalIndex ) ;
16008 0 : break ;
16009 0 : case V_SgAssignedGotoStatement:
16010 0 : returnPointer = SgAssignedGotoStatement::getPointerFromGlobalIndex( globalIndex ) ;
16011 0 : break ;
16012 0 : case V_SgAssociateStatement:
16013 0 : returnPointer = SgAssociateStatement::getPointerFromGlobalIndex( globalIndex ) ;
16014 0 : break ;
16015 0 : case V_SgAsteriskShapeExp:
16016 0 : returnPointer = SgAsteriskShapeExp::getPointerFromGlobalIndex( globalIndex ) ;
16017 0 : break ;
16018 0 : case V_SgAttribute:
16019 0 : returnPointer = SgAttribute::getPointerFromGlobalIndex( globalIndex ) ;
16020 0 : break ;
16021 0 : case V_SgAttributeSpecificationStatement:
16022 0 : returnPointer = SgAttributeSpecificationStatement::getPointerFromGlobalIndex( globalIndex ) ;
16023 0 : break ;
16024 38 : case V_SgAutoType:
16025 38 : returnPointer = SgAutoType::getPointerFromGlobalIndex( globalIndex ) ;
16026 38 : break ;
16027 0 : case V_SgAwaitExpression:
16028 0 : returnPointer = SgAwaitExpression::getPointerFromGlobalIndex( globalIndex ) ;
16029 0 : break ;
16030 0 : case V_SgBackspaceStatement:
16031 0 : returnPointer = SgBackspaceStatement::getPointerFromGlobalIndex( globalIndex ) ;
16032 0 : break ;
16033 4900 : case V_SgBaseClass:
16034 4900 : returnPointer = SgBaseClass::getPointerFromGlobalIndex( globalIndex ) ;
16035 4900 : break ;
16036 0 : case V_SgExpBaseClass:
16037 0 : returnPointer = SgExpBaseClass::getPointerFromGlobalIndex( globalIndex ) ;
16038 0 : break ;
16039 620 : case V_SgBaseClassModifier:
16040 620 : returnPointer = SgBaseClassModifier::getPointerFromGlobalIndex( globalIndex ) ;
16041 620 : break ;
16042 18453 : case V_SgBasicBlock:
16043 18453 : returnPointer = SgBasicBlock::getPointerFromGlobalIndex( globalIndex ) ;
16044 18453 : break ;
16045 0 : case V_SgBidirectionalGraph:
16046 0 : returnPointer = SgBidirectionalGraph::getPointerFromGlobalIndex( globalIndex ) ;
16047 0 : break ;
16048 0 : case V_SgBinaryOp:
16049 0 : returnPointer = SgBinaryOp::getPointerFromGlobalIndex( globalIndex ) ;
16050 0 : break ;
16051 120 : case V_SgBitAndOp:
16052 120 : returnPointer = SgBitAndOp::getPointerFromGlobalIndex( globalIndex ) ;
16053 120 : break ;
16054 0 : case V_SgBitAttribute:
16055 0 : returnPointer = SgBitAttribute::getPointerFromGlobalIndex( globalIndex ) ;
16056 0 : break ;
16057 55 : case V_SgBitComplementOp:
16058 55 : returnPointer = SgBitComplementOp::getPointerFromGlobalIndex( globalIndex ) ;
16059 55 : break ;
16060 0 : case V_SgBitEqvOp:
16061 0 : returnPointer = SgBitEqvOp::getPointerFromGlobalIndex( globalIndex ) ;
16062 0 : break ;
16063 90 : case V_SgBitOrOp:
16064 90 : returnPointer = SgBitOrOp::getPointerFromGlobalIndex( globalIndex ) ;
16065 90 : break ;
16066 36 : case V_SgBitXorOp:
16067 36 : returnPointer = SgBitXorOp::getPointerFromGlobalIndex( globalIndex ) ;
16068 36 : break ;
16069 0 : case V_SgBlockDataStatement:
16070 0 : returnPointer = SgBlockDataStatement::getPointerFromGlobalIndex( globalIndex ) ;
16071 0 : break ;
16072 1684 : case V_SgBoolValExp:
16073 1684 : returnPointer = SgBoolValExp::getPointerFromGlobalIndex( globalIndex ) ;
16074 1684 : break ;
16075 111 : case V_SgBreakStmt:
16076 111 : returnPointer = SgBreakStmt::getPointerFromGlobalIndex( globalIndex ) ;
16077 111 : break ;
16078 5 : case V_SgBracedInitializer:
16079 5 : returnPointer = SgBracedInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16080 5 : break ;
16081 0 : case V_SgC_PreprocessorDirectiveStatement:
16082 0 : returnPointer = SgC_PreprocessorDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16083 0 : break ;
16084 0 : case V_SgCaseOptionStmt:
16085 0 : returnPointer = SgCaseOptionStmt::getPointerFromGlobalIndex( globalIndex ) ;
16086 0 : break ;
16087 11305 : case V_SgCastExp:
16088 11305 : returnPointer = SgCastExp::getPointerFromGlobalIndex( globalIndex ) ;
16089 11305 : break ;
16090 720 : case V_SgCatchOptionStmt:
16091 720 : returnPointer = SgCatchOptionStmt::getPointerFromGlobalIndex( globalIndex ) ;
16092 720 : break ;
16093 252 : case V_SgCatchStatementSeq:
16094 252 : returnPointer = SgCatchStatementSeq::getPointerFromGlobalIndex( globalIndex ) ;
16095 252 : break ;
16096 188 : case V_SgCharVal:
16097 188 : returnPointer = SgCharVal::getPointerFromGlobalIndex( globalIndex ) ;
16098 188 : break ;
16099 0 : case V_SgChar16Val:
16100 0 : returnPointer = SgChar16Val::getPointerFromGlobalIndex( globalIndex ) ;
16101 0 : break ;
16102 0 : case V_SgChar32Val:
16103 0 : returnPointer = SgChar32Val::getPointerFromGlobalIndex( globalIndex ) ;
16104 0 : break ;
16105 0 : case V_SgChooseExpression:
16106 0 : returnPointer = SgChooseExpression::getPointerFromGlobalIndex( globalIndex ) ;
16107 0 : break ;
16108 0 : case V_SgClassDecl_attr:
16109 0 : returnPointer = SgClassDecl_attr::getPointerFromGlobalIndex( globalIndex ) ;
16110 0 : break ;
16111 2657 : case V_SgClassDeclaration:
16112 2657 : returnPointer = SgClassDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16113 2657 : break ;
16114 3720 : case V_SgClassDefinition:
16115 3720 : returnPointer = SgClassDefinition::getPointerFromGlobalIndex( globalIndex ) ;
16116 3720 : break ;
16117 0 : case V_SgClassNameRefExp:
16118 0 : returnPointer = SgClassNameRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16119 0 : break ;
16120 4404 : case V_SgClassSymbol:
16121 4404 : returnPointer = SgClassSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16122 4404 : break ;
16123 10121 : case V_SgClassType:
16124 10121 : returnPointer = SgClassType::getPointerFromGlobalIndex( globalIndex ) ;
16125 10121 : break ;
16126 0 : case V_SgClinkageDeclarationStatement:
16127 0 : returnPointer = SgClinkageDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
16128 0 : break ;
16129 0 : case V_SgClinkageEndStatement:
16130 0 : returnPointer = SgClinkageEndStatement::getPointerFromGlobalIndex( globalIndex ) ;
16131 0 : break ;
16132 0 : case V_SgClinkageStartStatement:
16133 0 : returnPointer = SgClinkageStartStatement::getPointerFromGlobalIndex( globalIndex ) ;
16134 0 : break ;
16135 0 : case V_SgCloseStatement:
16136 0 : returnPointer = SgCloseStatement::getPointerFromGlobalIndex( globalIndex ) ;
16137 0 : break ;
16138 0 : case V_SgColonShapeExp:
16139 0 : returnPointer = SgColonShapeExp::getPointerFromGlobalIndex( globalIndex ) ;
16140 0 : break ;
16141 96 : case V_SgCommaOpExp:
16142 96 : returnPointer = SgCommaOpExp::getPointerFromGlobalIndex( globalIndex ) ;
16143 96 : break ;
16144 0 : case V_SgCommonBlock:
16145 0 : returnPointer = SgCommonBlock::getPointerFromGlobalIndex( globalIndex ) ;
16146 0 : break ;
16147 0 : case V_SgCommonBlockObject:
16148 0 : returnPointer = SgCommonBlockObject::getPointerFromGlobalIndex( globalIndex ) ;
16149 0 : break ;
16150 0 : case V_SgCommonSymbol:
16151 0 : returnPointer = SgCommonSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16152 0 : break ;
16153 0 : case V_SgComplexVal:
16154 0 : returnPointer = SgComplexVal::getPointerFromGlobalIndex( globalIndex ) ;
16155 0 : break ;
16156 0 : case V_SgComprehension:
16157 0 : returnPointer = SgComprehension::getPointerFromGlobalIndex( globalIndex ) ;
16158 0 : break ;
16159 0 : case V_SgCompoundAssignOp:
16160 0 : returnPointer = SgCompoundAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16161 0 : break ;
16162 0 : case V_SgCompoundInitializer:
16163 0 : returnPointer = SgCompoundInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16164 0 : break ;
16165 0 : case V_SgCompoundLiteralExp:
16166 0 : returnPointer = SgCompoundLiteralExp::getPointerFromGlobalIndex( globalIndex ) ;
16167 0 : break ;
16168 0 : case V_SgComputedGotoStatement:
16169 0 : returnPointer = SgComputedGotoStatement::getPointerFromGlobalIndex( globalIndex ) ;
16170 0 : break ;
16171 0 : case V_SgConcatenationOp:
16172 0 : returnPointer = SgConcatenationOp::getPointerFromGlobalIndex( globalIndex ) ;
16173 0 : break ;
16174 497 : case V_SgConditionalExp:
16175 497 : returnPointer = SgConditionalExp::getPointerFromGlobalIndex( globalIndex ) ;
16176 497 : break ;
16177 0 : case V_SgConjugateOp:
16178 0 : returnPointer = SgConjugateOp::getPointerFromGlobalIndex( globalIndex ) ;
16179 0 : break ;
16180 0 : case V_SgConstVolatileModifier:
16181 0 : returnPointer = SgConstVolatileModifier::getPointerFromGlobalIndex( globalIndex ) ;
16182 0 : break ;
16183 2305 : case V_SgConstructorInitializer:
16184 2305 : returnPointer = SgConstructorInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16185 2305 : break ;
16186 0 : case V_SgContainsStatement:
16187 0 : returnPointer = SgContainsStatement::getPointerFromGlobalIndex( globalIndex ) ;
16188 0 : break ;
16189 8 : case V_SgContinueStmt:
16190 8 : returnPointer = SgContinueStmt::getPointerFromGlobalIndex( globalIndex ) ;
16191 8 : break ;
16192 22401 : case V_SgCtorInitializerList:
16193 22401 : returnPointer = SgCtorInitializerList::getPointerFromGlobalIndex( globalIndex ) ;
16194 22401 : break ;
16195 0 : case V_SgDataStatementGroup:
16196 0 : returnPointer = SgDataStatementGroup::getPointerFromGlobalIndex( globalIndex ) ;
16197 0 : break ;
16198 0 : case V_SgDataStatementObject:
16199 0 : returnPointer = SgDataStatementObject::getPointerFromGlobalIndex( globalIndex ) ;
16200 0 : break ;
16201 0 : case V_SgDataStatementValue:
16202 0 : returnPointer = SgDataStatementValue::getPointerFromGlobalIndex( globalIndex ) ;
16203 0 : break ;
16204 0 : case V_SgDeadIfDirectiveStatement:
16205 0 : returnPointer = SgDeadIfDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16206 0 : break ;
16207 0 : case V_SgDeallocateStatement:
16208 0 : returnPointer = SgDeallocateStatement::getPointerFromGlobalIndex( globalIndex ) ;
16209 0 : break ;
16210 0 : case V_SgDeclarationModifier:
16211 0 : returnPointer = SgDeclarationModifier::getPointerFromGlobalIndex( globalIndex ) ;
16212 0 : break ;
16213 46319 : case V_SgDeclarationScope:
16214 46319 : returnPointer = SgDeclarationScope::getPointerFromGlobalIndex( globalIndex ) ;
16215 46319 : break ;
16216 0 : case V_SgDeclarationStatement:
16217 0 : returnPointer = SgDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
16218 0 : break ;
16219 448 : case V_SgDeclType:
16220 448 : returnPointer = SgDeclType::getPointerFromGlobalIndex( globalIndex ) ;
16221 448 : break ;
16222 0 : case V_SgDefaultOptionStmt:
16223 0 : returnPointer = SgDefaultOptionStmt::getPointerFromGlobalIndex( globalIndex ) ;
16224 0 : break ;
16225 0 : case V_SgDefaultSymbol:
16226 0 : returnPointer = SgDefaultSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16227 0 : break ;
16228 0 : case V_SgDefineDirectiveStatement:
16229 0 : returnPointer = SgDefineDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16230 0 : break ;
16231 75 : case V_SgDeleteExp:
16232 75 : returnPointer = SgDeleteExp::getPointerFromGlobalIndex( globalIndex ) ;
16233 75 : break ;
16234 0 : case V_SgDerivedTypeStatement:
16235 0 : returnPointer = SgDerivedTypeStatement::getPointerFromGlobalIndex( globalIndex ) ;
16236 0 : break ;
16237 0 : case V_SgDesignatedInitializer:
16238 0 : returnPointer = SgDesignatedInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16239 0 : break ;
16240 0 : case V_SgDictionaryComprehension:
16241 0 : returnPointer = SgDictionaryComprehension::getPointerFromGlobalIndex( globalIndex ) ;
16242 0 : break ;
16243 0 : case V_SgDictionaryExp:
16244 0 : returnPointer = SgDictionaryExp::getPointerFromGlobalIndex( globalIndex ) ;
16245 0 : break ;
16246 0 : case V_SgDimensionObject:
16247 0 : returnPointer = SgDimensionObject::getPointerFromGlobalIndex( globalIndex ) ;
16248 0 : break ;
16249 0 : case V_SgDirectedGraphEdge:
16250 0 : returnPointer = SgDirectedGraphEdge::getPointerFromGlobalIndex( globalIndex ) ;
16251 0 : break ;
16252 0 : case V_SgDirectory:
16253 0 : returnPointer = SgDirectory::getPointerFromGlobalIndex( globalIndex ) ;
16254 0 : break ;
16255 2 : case V_SgDirectoryList:
16256 2 : returnPointer = SgDirectoryList::getPointerFromGlobalIndex( globalIndex ) ;
16257 2 : break ;
16258 6 : case V_SgDivAssignOp:
16259 6 : returnPointer = SgDivAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16260 6 : break ;
16261 222 : case V_SgDivideOp:
16262 222 : returnPointer = SgDivideOp::getPointerFromGlobalIndex( globalIndex ) ;
16263 222 : break ;
16264 49 : case V_SgDoWhileStmt:
16265 49 : returnPointer = SgDoWhileStmt::getPointerFromGlobalIndex( globalIndex ) ;
16266 49 : break ;
16267 4896 : case V_SgDotExp:
16268 4896 : returnPointer = SgDotExp::getPointerFromGlobalIndex( globalIndex ) ;
16269 4896 : break ;
16270 72 : case V_SgDotStarOp:
16271 72 : returnPointer = SgDotStarOp::getPointerFromGlobalIndex( globalIndex ) ;
16272 72 : break ;
16273 4 : case V_SgDoubleVal:
16274 4 : returnPointer = SgDoubleVal::getPointerFromGlobalIndex( globalIndex ) ;
16275 4 : break ;
16276 0 : case V_SgElaboratedTypeModifier:
16277 0 : returnPointer = SgElaboratedTypeModifier::getPointerFromGlobalIndex( globalIndex ) ;
16278 0 : break ;
16279 0 : case V_SgElementwiseOp:
16280 0 : returnPointer = SgElementwiseOp::getPointerFromGlobalIndex( globalIndex ) ;
16281 0 : break ;
16282 0 : case V_SgElementwiseAddOp:
16283 0 : returnPointer = SgElementwiseAddOp::getPointerFromGlobalIndex( globalIndex ) ;
16284 0 : break ;
16285 0 : case V_SgElementwiseDivideOp:
16286 0 : returnPointer = SgElementwiseDivideOp::getPointerFromGlobalIndex( globalIndex ) ;
16287 0 : break ;
16288 0 : case V_SgElementwiseLeftDivideOp:
16289 0 : returnPointer = SgElementwiseLeftDivideOp::getPointerFromGlobalIndex( globalIndex ) ;
16290 0 : break ;
16291 0 : case V_SgElementwiseMultiplyOp:
16292 0 : returnPointer = SgElementwiseMultiplyOp::getPointerFromGlobalIndex( globalIndex ) ;
16293 0 : break ;
16294 0 : case V_SgElementwisePowerOp:
16295 0 : returnPointer = SgElementwisePowerOp::getPointerFromGlobalIndex( globalIndex ) ;
16296 0 : break ;
16297 0 : case V_SgElementwiseSubtractOp:
16298 0 : returnPointer = SgElementwiseSubtractOp::getPointerFromGlobalIndex( globalIndex ) ;
16299 0 : break ;
16300 0 : case V_SgElseDirectiveStatement:
16301 0 : returnPointer = SgElseDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16302 0 : break ;
16303 0 : case V_SgElseWhereStatement:
16304 0 : returnPointer = SgElseWhereStatement::getPointerFromGlobalIndex( globalIndex ) ;
16305 0 : break ;
16306 0 : case V_SgElseifDirectiveStatement:
16307 0 : returnPointer = SgElseifDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16308 0 : break ;
16309 0 : case V_SgEmptyDeclaration:
16310 0 : returnPointer = SgEmptyDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16311 0 : break ;
16312 0 : case V_SgEmptyDirectiveStatement:
16313 0 : returnPointer = SgEmptyDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16314 0 : break ;
16315 0 : case V_SgEndfileStatement:
16316 0 : returnPointer = SgEndfileStatement::getPointerFromGlobalIndex( globalIndex ) ;
16317 0 : break ;
16318 0 : case V_SgEndifDirectiveStatement:
16319 0 : returnPointer = SgEndifDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16320 0 : break ;
16321 0 : case V_SgEntryStatement:
16322 0 : returnPointer = SgEntryStatement::getPointerFromGlobalIndex( globalIndex ) ;
16323 0 : break ;
16324 2094 : case V_SgEnumDeclaration:
16325 2094 : returnPointer = SgEnumDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16326 2094 : break ;
16327 432 : case V_SgEnumFieldSymbol:
16328 432 : returnPointer = SgEnumFieldSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16329 432 : break ;
16330 130 : case V_SgEnumSymbol:
16331 130 : returnPointer = SgEnumSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16332 130 : break ;
16333 757 : case V_SgEnumType:
16334 757 : returnPointer = SgEnumType::getPointerFromGlobalIndex( globalIndex ) ;
16335 757 : break ;
16336 2200 : case V_SgEnumVal:
16337 2200 : returnPointer = SgEnumVal::getPointerFromGlobalIndex( globalIndex ) ;
16338 2200 : break ;
16339 1500 : case V_SgEqualityOp:
16340 1500 : returnPointer = SgEqualityOp::getPointerFromGlobalIndex( globalIndex ) ;
16341 1500 : break ;
16342 0 : case V_SgEquivalenceStatement:
16343 0 : returnPointer = SgEquivalenceStatement::getPointerFromGlobalIndex( globalIndex ) ;
16344 0 : break ;
16345 0 : case V_SgErrorDirectiveStatement:
16346 0 : returnPointer = SgErrorDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16347 0 : break ;
16348 0 : case V_SgExecStatement:
16349 0 : returnPointer = SgExecStatement::getPointerFromGlobalIndex( globalIndex ) ;
16350 0 : break ;
16351 0 : case V_SgExponentiationOp:
16352 0 : returnPointer = SgExponentiationOp::getPointerFromGlobalIndex( globalIndex ) ;
16353 0 : break ;
16354 0 : case V_SgExponentiationAssignOp:
16355 0 : returnPointer = SgExponentiationAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16356 0 : break ;
16357 18798 : case V_SgExprListExp:
16358 18798 : returnPointer = SgExprListExp::getPointerFromGlobalIndex( globalIndex ) ;
16359 18798 : break ;
16360 9216 : case V_SgExprStatement:
16361 9216 : returnPointer = SgExprStatement::getPointerFromGlobalIndex( globalIndex ) ;
16362 9216 : break ;
16363 0 : case V_SgExpression:
16364 0 : returnPointer = SgExpression::getPointerFromGlobalIndex( globalIndex ) ;
16365 0 : break ;
16366 0 : case V_SgExpressionRoot:
16367 0 : returnPointer = SgExpressionRoot::getPointerFromGlobalIndex( globalIndex ) ;
16368 0 : break ;
16369 0 : case V_SgFile:
16370 0 : returnPointer = SgFile::getPointerFromGlobalIndex( globalIndex ) ;
16371 0 : break ;
16372 4 : case V_SgFileList:
16373 4 : returnPointer = SgFileList::getPointerFromGlobalIndex( globalIndex ) ;
16374 4 : break ;
16375 4 : case V_SgFloatVal:
16376 4 : returnPointer = SgFloatVal::getPointerFromGlobalIndex( globalIndex ) ;
16377 4 : break ;
16378 0 : case V_SgFloat128Val:
16379 0 : returnPointer = SgFloat128Val::getPointerFromGlobalIndex( globalIndex ) ;
16380 0 : break ;
16381 0 : case V_SgFloat80Val:
16382 0 : returnPointer = SgFloat80Val::getPointerFromGlobalIndex( globalIndex ) ;
16383 0 : break ;
16384 0 : case V_SgFoldExpression:
16385 0 : returnPointer = SgFoldExpression::getPointerFromGlobalIndex( globalIndex ) ;
16386 0 : break ;
16387 0 : case V_SgFlushStatement:
16388 0 : returnPointer = SgFlushStatement::getPointerFromGlobalIndex( globalIndex ) ;
16389 0 : break ;
16390 0 : case V_SgForAllStatement:
16391 0 : returnPointer = SgForAllStatement::getPointerFromGlobalIndex( globalIndex ) ;
16392 0 : break ;
16393 160 : case V_SgForInitStatement:
16394 160 : returnPointer = SgForInitStatement::getPointerFromGlobalIndex( globalIndex ) ;
16395 160 : break ;
16396 380 : case V_SgForStatement:
16397 380 : returnPointer = SgForStatement::getPointerFromGlobalIndex( globalIndex ) ;
16398 380 : break ;
16399 0 : case V_SgFormatItem:
16400 0 : returnPointer = SgFormatItem::getPointerFromGlobalIndex( globalIndex ) ;
16401 0 : break ;
16402 0 : case V_SgFormatItemList:
16403 0 : returnPointer = SgFormatItemList::getPointerFromGlobalIndex( globalIndex ) ;
16404 0 : break ;
16405 0 : case V_SgFormatStatement:
16406 0 : returnPointer = SgFormatStatement::getPointerFromGlobalIndex( globalIndex ) ;
16407 0 : break ;
16408 0 : case V_SgFortranDo:
16409 0 : returnPointer = SgFortranDo::getPointerFromGlobalIndex( globalIndex ) ;
16410 0 : break ;
16411 0 : case V_SgFortranIncludeLine:
16412 0 : returnPointer = SgFortranIncludeLine::getPointerFromGlobalIndex( globalIndex ) ;
16413 0 : break ;
16414 0 : case V_SgFortranNonblockedDo:
16415 0 : returnPointer = SgFortranNonblockedDo::getPointerFromGlobalIndex( globalIndex ) ;
16416 0 : break ;
16417 0 : case V_SgFuncDecl_attr:
16418 0 : returnPointer = SgFuncDecl_attr::getPointerFromGlobalIndex( globalIndex ) ;
16419 0 : break ;
16420 19319 : case V_SgFunctionCallExp:
16421 19319 : returnPointer = SgFunctionCallExp::getPointerFromGlobalIndex( globalIndex ) ;
16422 19319 : break ;
16423 74714 : case V_SgFunctionDeclaration:
16424 74714 : returnPointer = SgFunctionDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16425 74714 : break ;
16426 11761 : case V_SgFunctionDefinition:
16427 11761 : returnPointer = SgFunctionDefinition::getPointerFromGlobalIndex( globalIndex ) ;
16428 11761 : break ;
16429 0 : case V_SgFunctionParameterScope:
16430 0 : returnPointer = SgFunctionParameterScope::getPointerFromGlobalIndex( globalIndex ) ;
16431 0 : break ;
16432 0 : case V_SgFunctionModifier:
16433 0 : returnPointer = SgFunctionModifier::getPointerFromGlobalIndex( globalIndex ) ;
16434 0 : break ;
16435 144224 : case V_SgFunctionParameterList:
16436 144224 : returnPointer = SgFunctionParameterList::getPointerFromGlobalIndex( globalIndex ) ;
16437 144224 : break ;
16438 268 : case V_SgFunctionParameterRefExp:
16439 268 : returnPointer = SgFunctionParameterRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16440 268 : break ;
16441 5316 : case V_SgFunctionParameterTypeList:
16442 5316 : returnPointer = SgFunctionParameterTypeList::getPointerFromGlobalIndex( globalIndex ) ;
16443 5316 : break ;
16444 2432 : case V_SgFunctionRefExp:
16445 2432 : returnPointer = SgFunctionRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16446 2432 : break ;
16447 12603 : case V_SgFunctionSymbol:
16448 12603 : returnPointer = SgFunctionSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16449 12603 : break ;
16450 28713 : case V_SgFunctionType:
16451 28713 : returnPointer = SgFunctionType::getPointerFromGlobalIndex( globalIndex ) ;
16452 28713 : break ;
16453 13043 : case V_SgFunctionTypeSymbol:
16454 13043 : returnPointer = SgFunctionTypeSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16455 13043 : break ;
16456 8 : case V_SgFunctionTypeTable:
16457 8 : returnPointer = SgFunctionTypeTable::getPointerFromGlobalIndex( globalIndex ) ;
16458 8 : break ;
16459 26900 : case V_SgTypeTable:
16460 26900 : returnPointer = SgTypeTable::getPointerFromGlobalIndex( globalIndex ) ;
16461 26900 : break ;
16462 59049 : case V_SgGlobal:
16463 59049 : returnPointer = SgGlobal::getPointerFromGlobalIndex( globalIndex ) ;
16464 59049 : break ;
16465 0 : case V_SgGotoStatement:
16466 0 : returnPointer = SgGotoStatement::getPointerFromGlobalIndex( globalIndex ) ;
16467 0 : break ;
16468 0 : case V_SgGraph:
16469 0 : returnPointer = SgGraph::getPointerFromGlobalIndex( globalIndex ) ;
16470 0 : break ;
16471 0 : case V_SgGraphEdge:
16472 0 : returnPointer = SgGraphEdge::getPointerFromGlobalIndex( globalIndex ) ;
16473 0 : break ;
16474 0 : case V_SgGraphEdgeList:
16475 0 : returnPointer = SgGraphEdgeList::getPointerFromGlobalIndex( globalIndex ) ;
16476 0 : break ;
16477 0 : case V_SgGraphNode:
16478 0 : returnPointer = SgGraphNode::getPointerFromGlobalIndex( globalIndex ) ;
16479 0 : break ;
16480 0 : case V_SgGraphNodeList:
16481 0 : returnPointer = SgGraphNodeList::getPointerFromGlobalIndex( globalIndex ) ;
16482 0 : break ;
16483 168 : case V_SgGreaterOrEqualOp:
16484 168 : returnPointer = SgGreaterOrEqualOp::getPointerFromGlobalIndex( globalIndex ) ;
16485 168 : break ;
16486 648 : case V_SgGreaterThanOp:
16487 648 : returnPointer = SgGreaterThanOp::getPointerFromGlobalIndex( globalIndex ) ;
16488 648 : break ;
16489 0 : case V_SgIOItemExpression:
16490 0 : returnPointer = SgIOItemExpression::getPointerFromGlobalIndex( globalIndex ) ;
16491 0 : break ;
16492 0 : case V_SgIOStatement:
16493 0 : returnPointer = SgIOStatement::getPointerFromGlobalIndex( globalIndex ) ;
16494 0 : break ;
16495 0 : case V_SgIdentDirectiveStatement:
16496 0 : returnPointer = SgIdentDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16497 0 : break ;
16498 0 : case V_SgIfDirectiveStatement:
16499 0 : returnPointer = SgIfDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16500 0 : break ;
16501 4949 : case V_SgIfStmt:
16502 4949 : returnPointer = SgIfStmt::getPointerFromGlobalIndex( globalIndex ) ;
16503 4949 : break ;
16504 0 : case V_SgIfdefDirectiveStatement:
16505 0 : returnPointer = SgIfdefDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16506 0 : break ;
16507 0 : case V_SgIfndefDirectiveStatement:
16508 0 : returnPointer = SgIfndefDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16509 0 : break ;
16510 0 : case V_SgImageControlStatement:
16511 0 : returnPointer = SgImageControlStatement::getPointerFromGlobalIndex( globalIndex ) ;
16512 0 : break ;
16513 0 : case V_SgImagPartOp:
16514 0 : returnPointer = SgImagPartOp::getPointerFromGlobalIndex( globalIndex ) ;
16515 0 : break ;
16516 0 : case V_SgImplicitStatement:
16517 0 : returnPointer = SgImplicitStatement::getPointerFromGlobalIndex( globalIndex ) ;
16518 0 : break ;
16519 0 : case V_SgImpliedDo:
16520 0 : returnPointer = SgImpliedDo::getPointerFromGlobalIndex( globalIndex ) ;
16521 0 : break ;
16522 0 : case V_SgImportStatement:
16523 0 : returnPointer = SgImportStatement::getPointerFromGlobalIndex( globalIndex ) ;
16524 0 : break ;
16525 0 : case V_SgIncidenceDirectedGraph:
16526 0 : returnPointer = SgIncidenceDirectedGraph::getPointerFromGlobalIndex( globalIndex ) ;
16527 0 : break ;
16528 0 : case V_SgIncidenceUndirectedGraph:
16529 0 : returnPointer = SgIncidenceUndirectedGraph::getPointerFromGlobalIndex( globalIndex ) ;
16530 0 : break ;
16531 0 : case V_SgIncludeDirectiveStatement:
16532 0 : returnPointer = SgIncludeDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16533 0 : break ;
16534 1033 : case V_SgIncludeFile:
16535 1033 : returnPointer = SgIncludeFile::getPointerFromGlobalIndex( globalIndex ) ;
16536 1033 : break ;
16537 0 : case V_SgIncludeNextDirectiveStatement:
16538 0 : returnPointer = SgIncludeNextDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16539 0 : break ;
16540 229729 : case V_SgInitializedName:
16541 229729 : returnPointer = SgInitializedName::getPointerFromGlobalIndex( globalIndex ) ;
16542 229729 : break ;
16543 0 : case V_SgInitializer:
16544 0 : returnPointer = SgInitializer::getPointerFromGlobalIndex( globalIndex ) ;
16545 0 : break ;
16546 0 : case V_SgInquireStatement:
16547 0 : returnPointer = SgInquireStatement::getPointerFromGlobalIndex( globalIndex ) ;
16548 0 : break ;
16549 0 : case V_SgIntKeyedBidirectionalGraph:
16550 0 : returnPointer = SgIntKeyedBidirectionalGraph::getPointerFromGlobalIndex( globalIndex ) ;
16551 0 : break ;
16552 3700 : case V_SgIntVal:
16553 3700 : returnPointer = SgIntVal::getPointerFromGlobalIndex( globalIndex ) ;
16554 3700 : break ;
16555 0 : case V_SgIntegerDivideOp:
16556 0 : returnPointer = SgIntegerDivideOp::getPointerFromGlobalIndex( globalIndex ) ;
16557 0 : break ;
16558 0 : case V_SgIntegerDivideAssignOp:
16559 0 : returnPointer = SgIntegerDivideAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16560 0 : break ;
16561 0 : case V_SgInterfaceBody:
16562 0 : returnPointer = SgInterfaceBody::getPointerFromGlobalIndex( globalIndex ) ;
16563 0 : break ;
16564 0 : case V_SgHeaderFileBody:
16565 0 : returnPointer = SgHeaderFileBody::getPointerFromGlobalIndex( globalIndex ) ;
16566 0 : break ;
16567 0 : case V_SgHeaderFileReport:
16568 0 : returnPointer = SgHeaderFileReport::getPointerFromGlobalIndex( globalIndex ) ;
16569 0 : break ;
16570 0 : case V_SgInterfaceStatement:
16571 0 : returnPointer = SgInterfaceStatement::getPointerFromGlobalIndex( globalIndex ) ;
16572 0 : break ;
16573 0 : case V_SgInterfaceSymbol:
16574 0 : returnPointer = SgInterfaceSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16575 0 : break ;
16576 0 : case V_SgIntrinsicSymbol:
16577 0 : returnPointer = SgIntrinsicSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16578 0 : break ;
16579 0 : case V_SgIsOp:
16580 0 : returnPointer = SgIsOp::getPointerFromGlobalIndex( globalIndex ) ;
16581 0 : break ;
16582 0 : case V_SgIsNotOp:
16583 0 : returnPointer = SgIsNotOp::getPointerFromGlobalIndex( globalIndex ) ;
16584 0 : break ;
16585 42 : case V_SgIorAssignOp:
16586 42 : returnPointer = SgIorAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16587 42 : break ;
16588 0 : case V_SgKeyDatumPair:
16589 0 : returnPointer = SgKeyDatumPair::getPointerFromGlobalIndex( globalIndex ) ;
16590 0 : break ;
16591 0 : case V_SgCudaKernelExecConfig:
16592 0 : returnPointer = SgCudaKernelExecConfig::getPointerFromGlobalIndex( globalIndex ) ;
16593 0 : break ;
16594 0 : case V_SgCudaKernelCallExp:
16595 0 : returnPointer = SgCudaKernelCallExp::getPointerFromGlobalIndex( globalIndex ) ;
16596 0 : break ;
16597 0 : case V_SgLabelRefExp:
16598 0 : returnPointer = SgLabelRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16599 0 : break ;
16600 0 : case V_SgLabelStatement:
16601 0 : returnPointer = SgLabelStatement::getPointerFromGlobalIndex( globalIndex ) ;
16602 0 : break ;
16603 0 : case V_SgLabelSymbol:
16604 0 : returnPointer = SgLabelSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16605 0 : break ;
16606 0 : case V_SgLambdaCapture:
16607 0 : returnPointer = SgLambdaCapture::getPointerFromGlobalIndex( globalIndex ) ;
16608 0 : break ;
16609 0 : case V_SgLambdaCaptureList:
16610 0 : returnPointer = SgLambdaCaptureList::getPointerFromGlobalIndex( globalIndex ) ;
16611 0 : break ;
16612 0 : case V_SgLambdaExp:
16613 0 : returnPointer = SgLambdaExp::getPointerFromGlobalIndex( globalIndex ) ;
16614 0 : break ;
16615 0 : case V_SgLambdaRefExp:
16616 0 : returnPointer = SgLambdaRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16617 0 : break ;
16618 0 : case V_SgLeftDivideOp:
16619 0 : returnPointer = SgLeftDivideOp::getPointerFromGlobalIndex( globalIndex ) ;
16620 0 : break ;
16621 186 : case V_SgLessOrEqualOp:
16622 186 : returnPointer = SgLessOrEqualOp::getPointerFromGlobalIndex( globalIndex ) ;
16623 186 : break ;
16624 816 : case V_SgLessThanOp:
16625 816 : returnPointer = SgLessThanOp::getPointerFromGlobalIndex( globalIndex ) ;
16626 816 : break ;
16627 0 : case V_SgLineDirectiveStatement:
16628 0 : returnPointer = SgLineDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16629 0 : break ;
16630 0 : case V_SgLinemarkerDirectiveStatement:
16631 0 : returnPointer = SgLinemarkerDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16632 0 : break ;
16633 0 : case V_SgLinkageModifier:
16634 0 : returnPointer = SgLinkageModifier::getPointerFromGlobalIndex( globalIndex ) ;
16635 0 : break ;
16636 0 : case V_SgListComprehension:
16637 0 : returnPointer = SgListComprehension::getPointerFromGlobalIndex( globalIndex ) ;
16638 0 : break ;
16639 0 : case V_SgListExp:
16640 0 : returnPointer = SgListExp::getPointerFromGlobalIndex( globalIndex ) ;
16641 0 : break ;
16642 0 : case V_SgLocatedNode:
16643 0 : returnPointer = SgLocatedNode::getPointerFromGlobalIndex( globalIndex ) ;
16644 0 : break ;
16645 0 : case V_SgLocatedNodeSupport:
16646 0 : returnPointer = SgLocatedNodeSupport::getPointerFromGlobalIndex( globalIndex ) ;
16647 0 : break ;
16648 0 : case V_SgLongDoubleVal:
16649 0 : returnPointer = SgLongDoubleVal::getPointerFromGlobalIndex( globalIndex ) ;
16650 0 : break ;
16651 52 : case V_SgLongIntVal:
16652 52 : returnPointer = SgLongIntVal::getPointerFromGlobalIndex( globalIndex ) ;
16653 52 : break ;
16654 0 : case V_SgLongLongIntVal:
16655 0 : returnPointer = SgLongLongIntVal::getPointerFromGlobalIndex( globalIndex ) ;
16656 0 : break ;
16657 0 : case V_SgLshiftAssignOp:
16658 0 : returnPointer = SgLshiftAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16659 0 : break ;
16660 162 : case V_SgLshiftOp:
16661 162 : returnPointer = SgLshiftOp::getPointerFromGlobalIndex( globalIndex ) ;
16662 162 : break ;
16663 0 : case V_SgMagicColonExp:
16664 0 : returnPointer = SgMagicColonExp::getPointerFromGlobalIndex( globalIndex ) ;
16665 0 : break ;
16666 0 : case V_SgMatrixExp:
16667 0 : returnPointer = SgMatrixExp::getPointerFromGlobalIndex( globalIndex ) ;
16668 0 : break ;
16669 0 : case V_SgMatrixTransposeOp:
16670 0 : returnPointer = SgMatrixTransposeOp::getPointerFromGlobalIndex( globalIndex ) ;
16671 0 : break ;
16672 6877 : case V_SgMemberFunctionDeclaration:
16673 6877 : returnPointer = SgMemberFunctionDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16674 6877 : break ;
16675 2160 : case V_SgMemberFunctionRefExp:
16676 2160 : returnPointer = SgMemberFunctionRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16677 2160 : break ;
16678 4475 : case V_SgMemberFunctionSymbol:
16679 4475 : returnPointer = SgMemberFunctionSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16680 4475 : break ;
16681 13599 : case V_SgMemberFunctionType:
16682 13599 : returnPointer = SgMemberFunctionType::getPointerFromGlobalIndex( globalIndex ) ;
16683 13599 : break ;
16684 0 : case V_SgMembershipOp:
16685 0 : returnPointer = SgMembershipOp::getPointerFromGlobalIndex( globalIndex ) ;
16686 0 : break ;
16687 0 : case V_SgMicrosoftAttributeDeclaration:
16688 0 : returnPointer = SgMicrosoftAttributeDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
16689 0 : break ;
16690 60 : case V_SgMinusAssignOp:
16691 60 : returnPointer = SgMinusAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16692 60 : break ;
16693 240 : case V_SgMinusMinusOp:
16694 240 : returnPointer = SgMinusMinusOp::getPointerFromGlobalIndex( globalIndex ) ;
16695 240 : break ;
16696 285 : case V_SgMinusOp:
16697 285 : returnPointer = SgMinusOp::getPointerFromGlobalIndex( globalIndex ) ;
16698 285 : break ;
16699 0 : case V_SgModAssignOp:
16700 0 : returnPointer = SgModAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16701 0 : break ;
16702 30 : case V_SgModOp:
16703 30 : returnPointer = SgModOp::getPointerFromGlobalIndex( globalIndex ) ;
16704 30 : break ;
16705 0 : case V_SgModifier:
16706 0 : returnPointer = SgModifier::getPointerFromGlobalIndex( globalIndex ) ;
16707 0 : break ;
16708 0 : case V_SgModifierNodes:
16709 0 : returnPointer = SgModifierNodes::getPointerFromGlobalIndex( globalIndex ) ;
16710 0 : break ;
16711 2398 : case V_SgModifierType:
16712 2398 : returnPointer = SgModifierType::getPointerFromGlobalIndex( globalIndex ) ;
16713 2398 : break ;
16714 0 : case V_SgModuleStatement:
16715 0 : returnPointer = SgModuleStatement::getPointerFromGlobalIndex( globalIndex ) ;
16716 0 : break ;
16717 0 : case V_SgModuleSymbol:
16718 0 : returnPointer = SgModuleSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16719 0 : break ;
16720 12 : case V_SgMultAssignOp:
16721 12 : returnPointer = SgMultAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
16722 12 : break ;
16723 390 : case V_SgMultiplyOp:
16724 390 : returnPointer = SgMultiplyOp::getPointerFromGlobalIndex( globalIndex ) ;
16725 390 : break ;
16726 0 : case V_SgName:
16727 0 : returnPointer = SgName::getPointerFromGlobalIndex( globalIndex ) ;
16728 0 : break ;
16729 0 : case V_SgNameGroup:
16730 0 : returnPointer = SgNameGroup::getPointerFromGlobalIndex( globalIndex ) ;
16731 0 : break ;
16732 0 : case V_SgNamedType:
16733 0 : returnPointer = SgNamedType::getPointerFromGlobalIndex( globalIndex ) ;
16734 0 : break ;
16735 0 : case V_SgNamelistStatement:
16736 0 : returnPointer = SgNamelistStatement::getPointerFromGlobalIndex( globalIndex ) ;
16737 0 : break ;
16738 0 : case V_SgNamespaceAliasDeclarationStatement:
16739 0 : returnPointer = SgNamespaceAliasDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
16740 0 : break ;
16741 769 : case V_SgNamespaceDeclarationStatement:
16742 769 : returnPointer = SgNamespaceDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
16743 769 : break ;
16744 11357 : case V_SgNamespaceDefinitionStatement:
16745 11357 : returnPointer = SgNamespaceDefinitionStatement::getPointerFromGlobalIndex( globalIndex ) ;
16746 11357 : break ;
16747 326 : case V_SgNamespaceSymbol:
16748 326 : returnPointer = SgNamespaceSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16749 326 : break ;
16750 0 : case V_SgNaryOp:
16751 0 : returnPointer = SgNaryOp::getPointerFromGlobalIndex( globalIndex ) ;
16752 0 : break ;
16753 0 : case V_SgNaryBooleanOp:
16754 0 : returnPointer = SgNaryBooleanOp::getPointerFromGlobalIndex( globalIndex ) ;
16755 0 : break ;
16756 0 : case V_SgNaryComparisonOp:
16757 0 : returnPointer = SgNaryComparisonOp::getPointerFromGlobalIndex( globalIndex ) ;
16758 0 : break ;
16759 74 : case V_SgNewExp:
16760 74 : returnPointer = SgNewExp::getPointerFromGlobalIndex( globalIndex ) ;
16761 74 : break ;
16762 0 : case V_SgNode:
16763 0 : returnPointer = SgNode::getPointerFromGlobalIndex( globalIndex ) ;
16764 0 : break ;
16765 90 : case V_SgNoexceptOp:
16766 90 : returnPointer = SgNoexceptOp::getPointerFromGlobalIndex( globalIndex ) ;
16767 90 : break ;
16768 570 : case V_SgNotEqualOp:
16769 570 : returnPointer = SgNotEqualOp::getPointerFromGlobalIndex( globalIndex ) ;
16770 570 : break ;
16771 1100 : case V_SgNotOp:
16772 1100 : returnPointer = SgNotOp::getPointerFromGlobalIndex( globalIndex ) ;
16773 1100 : break ;
16774 0 : case V_SgNonMembershipOp:
16775 0 : returnPointer = SgNonMembershipOp::getPointerFromGlobalIndex( globalIndex ) ;
16776 0 : break ;
16777 31109 : case V_SgNonrealDecl:
16778 31109 : returnPointer = SgNonrealDecl::getPointerFromGlobalIndex( globalIndex ) ;
16779 31109 : break ;
16780 5976 : case V_SgNonrealRefExp:
16781 5976 : returnPointer = SgNonrealRefExp::getPointerFromGlobalIndex( globalIndex ) ;
16782 5976 : break ;
16783 7171 : case V_SgNonrealSymbol:
16784 7171 : returnPointer = SgNonrealSymbol::getPointerFromGlobalIndex( globalIndex ) ;
16785 7171 : break ;
16786 20197 : case V_SgNonrealType:
16787 20197 : returnPointer = SgNonrealType::getPointerFromGlobalIndex( globalIndex ) ;
16788 20197 : break ;
16789 947 : case V_SgNonrealBaseClass:
16790 947 : returnPointer = SgNonrealBaseClass::getPointerFromGlobalIndex( globalIndex ) ;
16791 947 : break ;
16792 484 : case V_SgNullExpression:
16793 484 : returnPointer = SgNullExpression::getPointerFromGlobalIndex( globalIndex ) ;
16794 484 : break ;
16795 22 : case V_SgNullptrValExp:
16796 22 : returnPointer = SgNullptrValExp::getPointerFromGlobalIndex( globalIndex ) ;
16797 22 : break ;
16798 60 : case V_SgNullStatement:
16799 60 : returnPointer = SgNullStatement::getPointerFromGlobalIndex( globalIndex ) ;
16800 60 : break ;
16801 0 : case V_SgNullifyStatement:
16802 0 : returnPointer = SgNullifyStatement::getPointerFromGlobalIndex( globalIndex ) ;
16803 0 : break ;
16804 0 : case V_SgOmpAtomicStatement:
16805 0 : returnPointer = SgOmpAtomicStatement::getPointerFromGlobalIndex( globalIndex ) ;
16806 0 : break ;
16807 0 : case V_SgOmpBarrierStatement:
16808 0 : returnPointer = SgOmpBarrierStatement::getPointerFromGlobalIndex( globalIndex ) ;
16809 0 : break ;
16810 0 : case V_SgOmpCriticalStatement:
16811 0 : returnPointer = SgOmpCriticalStatement::getPointerFromGlobalIndex( globalIndex ) ;
16812 0 : break ;
16813 0 : case V_SgUpirFieldBodyStatement:
16814 0 : returnPointer = SgUpirFieldBodyStatement::getPointerFromGlobalIndex( globalIndex ) ;
16815 0 : break ;
16816 0 : case V_SgUpirBodyStatement:
16817 0 : returnPointer = SgUpirBodyStatement::getPointerFromGlobalIndex( globalIndex ) ;
16818 0 : break ;
16819 0 : case V_SgUpirFieldStatement:
16820 0 : returnPointer = SgUpirFieldStatement::getPointerFromGlobalIndex( globalIndex ) ;
16821 0 : break ;
16822 0 : case V_SgOmpDoStatement:
16823 0 : returnPointer = SgOmpDoStatement::getPointerFromGlobalIndex( globalIndex ) ;
16824 0 : break ;
16825 0 : case V_SgOmpFlushStatement:
16826 0 : returnPointer = SgOmpFlushStatement::getPointerFromGlobalIndex( globalIndex ) ;
16827 0 : break ;
16828 0 : case V_SgOmpAllocateStatement:
16829 0 : returnPointer = SgOmpAllocateStatement::getPointerFromGlobalIndex( globalIndex ) ;
16830 0 : break ;
16831 0 : case V_SgOmpDeclareSimdStatement:
16832 0 : returnPointer = SgOmpDeclareSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16833 0 : break ;
16834 0 : case V_SgUpirWorksharingStatement:
16835 0 : returnPointer = SgUpirWorksharingStatement::getPointerFromGlobalIndex( globalIndex ) ;
16836 0 : break ;
16837 0 : case V_SgOmpForSimdStatement:
16838 0 : returnPointer = SgOmpForSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16839 0 : break ;
16840 0 : case V_SgOmpMasterStatement:
16841 0 : returnPointer = SgOmpMasterStatement::getPointerFromGlobalIndex( globalIndex ) ;
16842 0 : break ;
16843 0 : case V_SgOmpTaskyieldStatement:
16844 0 : returnPointer = SgOmpTaskyieldStatement::getPointerFromGlobalIndex( globalIndex ) ;
16845 0 : break ;
16846 0 : case V_SgOmpMetadirectiveStatement:
16847 0 : returnPointer = SgOmpMetadirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
16848 0 : break ;
16849 0 : case V_SgOmpOrderedStatement:
16850 0 : returnPointer = SgOmpOrderedStatement::getPointerFromGlobalIndex( globalIndex ) ;
16851 0 : break ;
16852 0 : case V_SgOmpOrderedDependStatement:
16853 0 : returnPointer = SgOmpOrderedDependStatement::getPointerFromGlobalIndex( globalIndex ) ;
16854 0 : break ;
16855 0 : case V_SgUpirSpmdStatement:
16856 0 : returnPointer = SgUpirSpmdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16857 0 : break ;
16858 0 : case V_SgOmpTeamsStatement:
16859 0 : returnPointer = SgOmpTeamsStatement::getPointerFromGlobalIndex( globalIndex ) ;
16860 0 : break ;
16861 0 : case V_SgOmpCancellationPointStatement:
16862 0 : returnPointer = SgOmpCancellationPointStatement::getPointerFromGlobalIndex( globalIndex ) ;
16863 0 : break ;
16864 0 : case V_SgOmpDeclareMapperStatement:
16865 0 : returnPointer = SgOmpDeclareMapperStatement::getPointerFromGlobalIndex( globalIndex ) ;
16866 0 : break ;
16867 0 : case V_SgOmpCancelStatement:
16868 0 : returnPointer = SgOmpCancelStatement::getPointerFromGlobalIndex( globalIndex ) ;
16869 0 : break ;
16870 0 : case V_SgOmpTaskgroupStatement:
16871 0 : returnPointer = SgOmpTaskgroupStatement::getPointerFromGlobalIndex( globalIndex ) ;
16872 0 : break ;
16873 0 : case V_SgOmpDepobjStatement:
16874 0 : returnPointer = SgOmpDepobjStatement::getPointerFromGlobalIndex( globalIndex ) ;
16875 0 : break ;
16876 0 : case V_SgOmpDistributeStatement:
16877 0 : returnPointer = SgOmpDistributeStatement::getPointerFromGlobalIndex( globalIndex ) ;
16878 0 : break ;
16879 0 : case V_SgOmpLoopStatement:
16880 0 : returnPointer = SgOmpLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16881 0 : break ;
16882 0 : case V_SgOmpScanStatement:
16883 0 : returnPointer = SgOmpScanStatement::getPointerFromGlobalIndex( globalIndex ) ;
16884 0 : break ;
16885 0 : case V_SgOmpTaskloopStatement:
16886 0 : returnPointer = SgOmpTaskloopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16887 0 : break ;
16888 0 : case V_SgOmpTargetEnterDataStatement:
16889 0 : returnPointer = SgOmpTargetEnterDataStatement::getPointerFromGlobalIndex( globalIndex ) ;
16890 0 : break ;
16891 0 : case V_SgOmpTargetExitDataStatement:
16892 0 : returnPointer = SgOmpTargetExitDataStatement::getPointerFromGlobalIndex( globalIndex ) ;
16893 0 : break ;
16894 0 : case V_SgOmpSectionStatement:
16895 0 : returnPointer = SgOmpSectionStatement::getPointerFromGlobalIndex( globalIndex ) ;
16896 0 : break ;
16897 0 : case V_SgOmpSectionsStatement:
16898 0 : returnPointer = SgOmpSectionsStatement::getPointerFromGlobalIndex( globalIndex ) ;
16899 0 : break ;
16900 0 : case V_SgOmpSingleStatement:
16901 0 : returnPointer = SgOmpSingleStatement::getPointerFromGlobalIndex( globalIndex ) ;
16902 0 : break ;
16903 0 : case V_SgOmpTaskStatement:
16904 0 : returnPointer = SgOmpTaskStatement::getPointerFromGlobalIndex( globalIndex ) ;
16905 0 : break ;
16906 0 : case V_SgOmpTaskwaitStatement:
16907 0 : returnPointer = SgOmpTaskwaitStatement::getPointerFromGlobalIndex( globalIndex ) ;
16908 0 : break ;
16909 0 : case V_SgOmpThreadprivateStatement:
16910 0 : returnPointer = SgOmpThreadprivateStatement::getPointerFromGlobalIndex( globalIndex ) ;
16911 0 : break ;
16912 0 : case V_SgOmpWorkshareStatement:
16913 0 : returnPointer = SgOmpWorkshareStatement::getPointerFromGlobalIndex( globalIndex ) ;
16914 0 : break ;
16915 0 : case V_SgUpirTaskStatement:
16916 0 : returnPointer = SgUpirTaskStatement::getPointerFromGlobalIndex( globalIndex ) ;
16917 0 : break ;
16918 0 : case V_SgOmpTargetDataStatement:
16919 0 : returnPointer = SgOmpTargetDataStatement::getPointerFromGlobalIndex( globalIndex ) ;
16920 0 : break ;
16921 0 : case V_SgOmpTargetParallelForStatement:
16922 0 : returnPointer = SgOmpTargetParallelForStatement::getPointerFromGlobalIndex( globalIndex ) ;
16923 0 : break ;
16924 0 : case V_SgOmpTargetUpdateStatement:
16925 0 : returnPointer = SgOmpTargetUpdateStatement::getPointerFromGlobalIndex( globalIndex ) ;
16926 0 : break ;
16927 0 : case V_SgOmpRequiresStatement:
16928 0 : returnPointer = SgOmpRequiresStatement::getPointerFromGlobalIndex( globalIndex ) ;
16929 0 : break ;
16930 0 : case V_SgOmpTargetParallelStatement:
16931 0 : returnPointer = SgOmpTargetParallelStatement::getPointerFromGlobalIndex( globalIndex ) ;
16932 0 : break ;
16933 0 : case V_SgOmpTargetParallelForSimdStatement:
16934 0 : returnPointer = SgOmpTargetParallelForSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16935 0 : break ;
16936 0 : case V_SgOmpTargetParallelLoopStatement:
16937 0 : returnPointer = SgOmpTargetParallelLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16938 0 : break ;
16939 0 : case V_SgOmpTargetSimdStatement:
16940 0 : returnPointer = SgOmpTargetSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16941 0 : break ;
16942 0 : case V_SgOmpTargetTeamsStatement:
16943 0 : returnPointer = SgOmpTargetTeamsStatement::getPointerFromGlobalIndex( globalIndex ) ;
16944 0 : break ;
16945 0 : case V_SgOmpTargetTeamsDistributeStatement:
16946 0 : returnPointer = SgOmpTargetTeamsDistributeStatement::getPointerFromGlobalIndex( globalIndex ) ;
16947 0 : break ;
16948 0 : case V_SgOmpTargetTeamsDistributeSimdStatement:
16949 0 : returnPointer = SgOmpTargetTeamsDistributeSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16950 0 : break ;
16951 0 : case V_SgOmpTargetTeamsLoopStatement:
16952 0 : returnPointer = SgOmpTargetTeamsLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16953 0 : break ;
16954 0 : case V_SgOmpTargetTeamsDistributeParallelForStatement:
16955 0 : returnPointer = SgOmpTargetTeamsDistributeParallelForStatement::getPointerFromGlobalIndex( globalIndex ) ;
16956 0 : break ;
16957 0 : case V_SgOmpTargetTeamsDistributeParallelForSimdStatement:
16958 0 : returnPointer = SgOmpTargetTeamsDistributeParallelForSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16959 0 : break ;
16960 0 : case V_SgOmpDistributeSimdStatement:
16961 0 : returnPointer = SgOmpDistributeSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16962 0 : break ;
16963 0 : case V_SgOmpDistributeParallelForStatement:
16964 0 : returnPointer = SgOmpDistributeParallelForStatement::getPointerFromGlobalIndex( globalIndex ) ;
16965 0 : break ;
16966 0 : case V_SgOmpDistributeParallelForSimdStatement:
16967 0 : returnPointer = SgOmpDistributeParallelForSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16968 0 : break ;
16969 0 : case V_SgOmpTaskloopSimdStatement:
16970 0 : returnPointer = SgOmpTaskloopSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16971 0 : break ;
16972 0 : case V_SgOmpMasterTaskloopSimdStatement:
16973 0 : returnPointer = SgOmpMasterTaskloopSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16974 0 : break ;
16975 0 : case V_SgOmpParallelMasterTaskloopStatement:
16976 0 : returnPointer = SgOmpParallelMasterTaskloopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16977 0 : break ;
16978 0 : case V_SgOmpParallelMasterTaskloopSimdStatement:
16979 0 : returnPointer = SgOmpParallelMasterTaskloopSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16980 0 : break ;
16981 0 : case V_SgOmpTeamsDistributeStatement:
16982 0 : returnPointer = SgOmpTeamsDistributeStatement::getPointerFromGlobalIndex( globalIndex ) ;
16983 0 : break ;
16984 0 : case V_SgOmpTeamsDistributeSimdStatement:
16985 0 : returnPointer = SgOmpTeamsDistributeSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16986 0 : break ;
16987 0 : case V_SgOmpTeamsDistributeParallelForStatement:
16988 0 : returnPointer = SgOmpTeamsDistributeParallelForStatement::getPointerFromGlobalIndex( globalIndex ) ;
16989 0 : break ;
16990 0 : case V_SgOmpTeamsDistributeParallelForSimdStatement:
16991 0 : returnPointer = SgOmpTeamsDistributeParallelForSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
16992 0 : break ;
16993 0 : case V_SgOmpTeamsLoopStatement:
16994 0 : returnPointer = SgOmpTeamsLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16995 0 : break ;
16996 0 : case V_SgOmpParallelLoopStatement:
16997 0 : returnPointer = SgOmpParallelLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
16998 0 : break ;
16999 0 : case V_SgOmpParallelMasterStatement:
17000 0 : returnPointer = SgOmpParallelMasterStatement::getPointerFromGlobalIndex( globalIndex ) ;
17001 0 : break ;
17002 0 : case V_SgOmpMasterTaskloopStatement:
17003 0 : returnPointer = SgOmpMasterTaskloopStatement::getPointerFromGlobalIndex( globalIndex ) ;
17004 0 : break ;
17005 0 : case V_SgOmpUnrollStatement:
17006 0 : returnPointer = SgOmpUnrollStatement::getPointerFromGlobalIndex( globalIndex ) ;
17007 0 : break ;
17008 0 : case V_SgOmpTileStatement:
17009 0 : returnPointer = SgOmpTileStatement::getPointerFromGlobalIndex( globalIndex ) ;
17010 0 : break ;
17011 0 : case V_SgUpirSimdStatement:
17012 0 : returnPointer = SgUpirSimdStatement::getPointerFromGlobalIndex( globalIndex ) ;
17013 0 : break ;
17014 0 : case V_SgUpirBaseStatement:
17015 0 : returnPointer = SgUpirBaseStatement::getPointerFromGlobalIndex( globalIndex ) ;
17016 0 : break ;
17017 0 : case V_SgUpirLoopStatement:
17018 0 : returnPointer = SgUpirLoopStatement::getPointerFromGlobalIndex( globalIndex ) ;
17019 0 : break ;
17020 0 : case V_SgUpirLoopParallelStatement:
17021 0 : returnPointer = SgUpirLoopParallelStatement::getPointerFromGlobalIndex( globalIndex ) ;
17022 0 : break ;
17023 0 : case V_SgUpirSyncStatement:
17024 0 : returnPointer = SgUpirSyncStatement::getPointerFromGlobalIndex( globalIndex ) ;
17025 0 : break ;
17026 0 : case V_SgOmpClause:
17027 0 : returnPointer = SgOmpClause::getPointerFromGlobalIndex( globalIndex ) ;
17028 0 : break ;
17029 0 : case V_SgOmpAllocateClause:
17030 0 : returnPointer = SgOmpAllocateClause::getPointerFromGlobalIndex( globalIndex ) ;
17031 0 : break ;
17032 0 : case V_SgOmpAllocatorClause:
17033 0 : returnPointer = SgOmpAllocatorClause::getPointerFromGlobalIndex( globalIndex ) ;
17034 0 : break ;
17035 0 : case V_SgOmpUsesAllocatorsClause:
17036 0 : returnPointer = SgOmpUsesAllocatorsClause::getPointerFromGlobalIndex( globalIndex ) ;
17037 0 : break ;
17038 0 : case V_SgOmpUsesAllocatorsDefination:
17039 0 : returnPointer = SgOmpUsesAllocatorsDefination::getPointerFromGlobalIndex( globalIndex ) ;
17040 0 : break ;
17041 0 : case V_SgOmpToClause:
17042 0 : returnPointer = SgOmpToClause::getPointerFromGlobalIndex( globalIndex ) ;
17043 0 : break ;
17044 0 : case V_SgOmpFromClause:
17045 0 : returnPointer = SgOmpFromClause::getPointerFromGlobalIndex( globalIndex ) ;
17046 0 : break ;
17047 0 : case V_SgOmpThreadsClause:
17048 0 : returnPointer = SgOmpThreadsClause::getPointerFromGlobalIndex( globalIndex ) ;
17049 0 : break ;
17050 0 : case V_SgOmpSimdClause:
17051 0 : returnPointer = SgOmpSimdClause::getPointerFromGlobalIndex( globalIndex ) ;
17052 0 : break ;
17053 0 : case V_SgOmpBeginClause:
17054 0 : returnPointer = SgOmpBeginClause::getPointerFromGlobalIndex( globalIndex ) ;
17055 0 : break ;
17056 0 : case V_SgOmpCollapseClause:
17057 0 : returnPointer = SgOmpCollapseClause::getPointerFromGlobalIndex( globalIndex ) ;
17058 0 : break ;
17059 0 : case V_SgOmpCopyinClause:
17060 0 : returnPointer = SgOmpCopyinClause::getPointerFromGlobalIndex( globalIndex ) ;
17061 0 : break ;
17062 0 : case V_SgOmpCopyprivateClause:
17063 0 : returnPointer = SgOmpCopyprivateClause::getPointerFromGlobalIndex( globalIndex ) ;
17064 0 : break ;
17065 0 : case V_SgOmpDefaultClause:
17066 0 : returnPointer = SgOmpDefaultClause::getPointerFromGlobalIndex( globalIndex ) ;
17067 0 : break ;
17068 0 : case V_SgOmpEndClause:
17069 0 : returnPointer = SgOmpEndClause::getPointerFromGlobalIndex( globalIndex ) ;
17070 0 : break ;
17071 0 : case V_SgOmpExpressionClause:
17072 0 : returnPointer = SgOmpExpressionClause::getPointerFromGlobalIndex( globalIndex ) ;
17073 0 : break ;
17074 0 : case V_SgOmpFirstprivateClause:
17075 0 : returnPointer = SgOmpFirstprivateClause::getPointerFromGlobalIndex( globalIndex ) ;
17076 0 : break ;
17077 0 : case V_SgOmpIfClause:
17078 0 : returnPointer = SgOmpIfClause::getPointerFromGlobalIndex( globalIndex ) ;
17079 0 : break ;
17080 0 : case V_SgOmpFinalClause:
17081 0 : returnPointer = SgOmpFinalClause::getPointerFromGlobalIndex( globalIndex ) ;
17082 0 : break ;
17083 0 : case V_SgOmpPriorityClause:
17084 0 : returnPointer = SgOmpPriorityClause::getPointerFromGlobalIndex( globalIndex ) ;
17085 0 : break ;
17086 0 : case V_SgOmpDeviceClause:
17087 0 : returnPointer = SgOmpDeviceClause::getPointerFromGlobalIndex( globalIndex ) ;
17088 0 : break ;
17089 0 : case V_SgOmpLastprivateClause:
17090 0 : returnPointer = SgOmpLastprivateClause::getPointerFromGlobalIndex( globalIndex ) ;
17091 0 : break ;
17092 0 : case V_SgOmpNowaitClause:
17093 0 : returnPointer = SgOmpNowaitClause::getPointerFromGlobalIndex( globalIndex ) ;
17094 0 : break ;
17095 0 : case V_SgOmpReadClause:
17096 0 : returnPointer = SgOmpReadClause::getPointerFromGlobalIndex( globalIndex ) ;
17097 0 : break ;
17098 0 : case V_SgOmpWriteClause:
17099 0 : returnPointer = SgOmpWriteClause::getPointerFromGlobalIndex( globalIndex ) ;
17100 0 : break ;
17101 0 : case V_SgOmpUpdateClause:
17102 0 : returnPointer = SgOmpUpdateClause::getPointerFromGlobalIndex( globalIndex ) ;
17103 0 : break ;
17104 0 : case V_SgOmpDepobjUpdateClause:
17105 0 : returnPointer = SgOmpDepobjUpdateClause::getPointerFromGlobalIndex( globalIndex ) ;
17106 0 : break ;
17107 0 : case V_SgOmpDestroyClause:
17108 0 : returnPointer = SgOmpDestroyClause::getPointerFromGlobalIndex( globalIndex ) ;
17109 0 : break ;
17110 0 : case V_SgOmpCaptureClause:
17111 0 : returnPointer = SgOmpCaptureClause::getPointerFromGlobalIndex( globalIndex ) ;
17112 0 : break ;
17113 0 : case V_SgOmpSeqCstClause:
17114 0 : returnPointer = SgOmpSeqCstClause::getPointerFromGlobalIndex( globalIndex ) ;
17115 0 : break ;
17116 0 : case V_SgOmpAcqRelClause:
17117 0 : returnPointer = SgOmpAcqRelClause::getPointerFromGlobalIndex( globalIndex ) ;
17118 0 : break ;
17119 0 : case V_SgOmpReleaseClause:
17120 0 : returnPointer = SgOmpReleaseClause::getPointerFromGlobalIndex( globalIndex ) ;
17121 0 : break ;
17122 0 : case V_SgOmpAcquireClause:
17123 0 : returnPointer = SgOmpAcquireClause::getPointerFromGlobalIndex( globalIndex ) ;
17124 0 : break ;
17125 0 : case V_SgOmpReverseOffloadClause:
17126 0 : returnPointer = SgOmpReverseOffloadClause::getPointerFromGlobalIndex( globalIndex ) ;
17127 0 : break ;
17128 0 : case V_SgOmpUnifiedAddressClause:
17129 0 : returnPointer = SgOmpUnifiedAddressClause::getPointerFromGlobalIndex( globalIndex ) ;
17130 0 : break ;
17131 0 : case V_SgOmpUnifiedSharedMemoryClause:
17132 0 : returnPointer = SgOmpUnifiedSharedMemoryClause::getPointerFromGlobalIndex( globalIndex ) ;
17133 0 : break ;
17134 0 : case V_SgOmpDynamicAllocatorsClause:
17135 0 : returnPointer = SgOmpDynamicAllocatorsClause::getPointerFromGlobalIndex( globalIndex ) ;
17136 0 : break ;
17137 0 : case V_SgOmpAtomicDefaultMemOrderClause:
17138 0 : returnPointer = SgOmpAtomicDefaultMemOrderClause::getPointerFromGlobalIndex( globalIndex ) ;
17139 0 : break ;
17140 0 : case V_SgOmpExtImplementationDefinedRequirementClause:
17141 0 : returnPointer = SgOmpExtImplementationDefinedRequirementClause::getPointerFromGlobalIndex( globalIndex ) ;
17142 0 : break ;
17143 0 : case V_SgOmpRelaxedClause:
17144 0 : returnPointer = SgOmpRelaxedClause::getPointerFromGlobalIndex( globalIndex ) ;
17145 0 : break ;
17146 0 : case V_SgOmpParallelClause:
17147 0 : returnPointer = SgOmpParallelClause::getPointerFromGlobalIndex( globalIndex ) ;
17148 0 : break ;
17149 0 : case V_SgOmpSectionsClause:
17150 0 : returnPointer = SgOmpSectionsClause::getPointerFromGlobalIndex( globalIndex ) ;
17151 0 : break ;
17152 0 : case V_SgOmpForClause:
17153 0 : returnPointer = SgOmpForClause::getPointerFromGlobalIndex( globalIndex ) ;
17154 0 : break ;
17155 0 : case V_SgOmpTaskgroupClause:
17156 0 : returnPointer = SgOmpTaskgroupClause::getPointerFromGlobalIndex( globalIndex ) ;
17157 0 : break ;
17158 0 : case V_SgUpirNumUnitsField:
17159 0 : returnPointer = SgUpirNumUnitsField::getPointerFromGlobalIndex( globalIndex ) ;
17160 0 : break ;
17161 0 : case V_SgOmpNumTeamsClause:
17162 0 : returnPointer = SgOmpNumTeamsClause::getPointerFromGlobalIndex( globalIndex ) ;
17163 0 : break ;
17164 0 : case V_SgOmpGrainsizeClause:
17165 0 : returnPointer = SgOmpGrainsizeClause::getPointerFromGlobalIndex( globalIndex ) ;
17166 0 : break ;
17167 0 : case V_SgOmpDetachClause:
17168 0 : returnPointer = SgOmpDetachClause::getPointerFromGlobalIndex( globalIndex ) ;
17169 0 : break ;
17170 0 : case V_SgOmpNumTasksClause:
17171 0 : returnPointer = SgOmpNumTasksClause::getPointerFromGlobalIndex( globalIndex ) ;
17172 0 : break ;
17173 0 : case V_SgOmpNogroupClause:
17174 0 : returnPointer = SgOmpNogroupClause::getPointerFromGlobalIndex( globalIndex ) ;
17175 0 : break ;
17176 0 : case V_SgOmpHintClause:
17177 0 : returnPointer = SgOmpHintClause::getPointerFromGlobalIndex( globalIndex ) ;
17178 0 : break ;
17179 0 : case V_SgOmpOrderClause:
17180 0 : returnPointer = SgOmpOrderClause::getPointerFromGlobalIndex( globalIndex ) ;
17181 0 : break ;
17182 0 : case V_SgOmpDistScheduleClause:
17183 0 : returnPointer = SgOmpDistScheduleClause::getPointerFromGlobalIndex( globalIndex ) ;
17184 0 : break ;
17185 0 : case V_SgOmpBindClause:
17186 0 : returnPointer = SgOmpBindClause::getPointerFromGlobalIndex( globalIndex ) ;
17187 0 : break ;
17188 0 : case V_SgOmpNontemporalClause:
17189 0 : returnPointer = SgOmpNontemporalClause::getPointerFromGlobalIndex( globalIndex ) ;
17190 0 : break ;
17191 0 : case V_SgOmpInclusiveClause:
17192 0 : returnPointer = SgOmpInclusiveClause::getPointerFromGlobalIndex( globalIndex ) ;
17193 0 : break ;
17194 0 : case V_SgOmpExclusiveClause:
17195 0 : returnPointer = SgOmpExclusiveClause::getPointerFromGlobalIndex( globalIndex ) ;
17196 0 : break ;
17197 0 : case V_SgOmpIsDevicePtrClause:
17198 0 : returnPointer = SgOmpIsDevicePtrClause::getPointerFromGlobalIndex( globalIndex ) ;
17199 0 : break ;
17200 0 : case V_SgOmpUseDevicePtrClause:
17201 0 : returnPointer = SgOmpUseDevicePtrClause::getPointerFromGlobalIndex( globalIndex ) ;
17202 0 : break ;
17203 0 : case V_SgOmpUseDeviceAddrClause:
17204 0 : returnPointer = SgOmpUseDeviceAddrClause::getPointerFromGlobalIndex( globalIndex ) ;
17205 0 : break ;
17206 0 : case V_SgOmpThreadLimitClause:
17207 0 : returnPointer = SgOmpThreadLimitClause::getPointerFromGlobalIndex( globalIndex ) ;
17208 0 : break ;
17209 0 : case V_SgOmpOrderedClause:
17210 0 : returnPointer = SgOmpOrderedClause::getPointerFromGlobalIndex( globalIndex ) ;
17211 0 : break ;
17212 0 : case V_SgOmpPrivateClause:
17213 0 : returnPointer = SgOmpPrivateClause::getPointerFromGlobalIndex( globalIndex ) ;
17214 0 : break ;
17215 0 : case V_SgOmpReductionClause:
17216 0 : returnPointer = SgOmpReductionClause::getPointerFromGlobalIndex( globalIndex ) ;
17217 0 : break ;
17218 0 : case V_SgOmpInReductionClause:
17219 0 : returnPointer = SgOmpInReductionClause::getPointerFromGlobalIndex( globalIndex ) ;
17220 0 : break ;
17221 0 : case V_SgOmpTaskReductionClause:
17222 0 : returnPointer = SgOmpTaskReductionClause::getPointerFromGlobalIndex( globalIndex ) ;
17223 0 : break ;
17224 0 : case V_SgOmpDefaultmapClause:
17225 0 : returnPointer = SgOmpDefaultmapClause::getPointerFromGlobalIndex( globalIndex ) ;
17226 0 : break ;
17227 0 : case V_SgOmpScheduleClause:
17228 0 : returnPointer = SgOmpScheduleClause::getPointerFromGlobalIndex( globalIndex ) ;
17229 0 : break ;
17230 0 : case V_SgOmpSharedClause:
17231 0 : returnPointer = SgOmpSharedClause::getPointerFromGlobalIndex( globalIndex ) ;
17232 0 : break ;
17233 0 : case V_SgOmpUntiedClause:
17234 0 : returnPointer = SgOmpUntiedClause::getPointerFromGlobalIndex( globalIndex ) ;
17235 0 : break ;
17236 0 : case V_SgOmpMergeableClause:
17237 0 : returnPointer = SgOmpMergeableClause::getPointerFromGlobalIndex( globalIndex ) ;
17238 0 : break ;
17239 0 : case V_SgOmpVariablesClause:
17240 0 : returnPointer = SgOmpVariablesClause::getPointerFromGlobalIndex( globalIndex ) ;
17241 0 : break ;
17242 0 : case V_SgOmpMapClause:
17243 0 : returnPointer = SgOmpMapClause::getPointerFromGlobalIndex( globalIndex ) ;
17244 0 : break ;
17245 0 : case V_SgOmpSafelenClause:
17246 0 : returnPointer = SgOmpSafelenClause::getPointerFromGlobalIndex( globalIndex ) ;
17247 0 : break ;
17248 0 : case V_SgOmpSimdlenClause:
17249 0 : returnPointer = SgOmpSimdlenClause::getPointerFromGlobalIndex( globalIndex ) ;
17250 0 : break ;
17251 0 : case V_SgOmpLinearClause:
17252 0 : returnPointer = SgOmpLinearClause::getPointerFromGlobalIndex( globalIndex ) ;
17253 0 : break ;
17254 0 : case V_SgOmpUniformClause:
17255 0 : returnPointer = SgOmpUniformClause::getPointerFromGlobalIndex( globalIndex ) ;
17256 0 : break ;
17257 0 : case V_SgOmpAlignedClause:
17258 0 : returnPointer = SgOmpAlignedClause::getPointerFromGlobalIndex( globalIndex ) ;
17259 0 : break ;
17260 0 : case V_SgOmpProcBindClause:
17261 0 : returnPointer = SgOmpProcBindClause::getPointerFromGlobalIndex( globalIndex ) ;
17262 0 : break ;
17263 0 : case V_SgOmpAtomicClause:
17264 0 : returnPointer = SgOmpAtomicClause::getPointerFromGlobalIndex( globalIndex ) ;
17265 0 : break ;
17266 0 : case V_SgOmpInbranchClause:
17267 0 : returnPointer = SgOmpInbranchClause::getPointerFromGlobalIndex( globalIndex ) ;
17268 0 : break ;
17269 0 : case V_SgOmpNotinbranchClause:
17270 0 : returnPointer = SgOmpNotinbranchClause::getPointerFromGlobalIndex( globalIndex ) ;
17271 0 : break ;
17272 0 : case V_SgOmpDependClause:
17273 0 : returnPointer = SgOmpDependClause::getPointerFromGlobalIndex( globalIndex ) ;
17274 0 : break ;
17275 0 : case V_SgOmpAffinityClause:
17276 0 : returnPointer = SgOmpAffinityClause::getPointerFromGlobalIndex( globalIndex ) ;
17277 0 : break ;
17278 0 : case V_SgOmpWhenClause:
17279 0 : returnPointer = SgOmpWhenClause::getPointerFromGlobalIndex( globalIndex ) ;
17280 0 : break ;
17281 0 : case V_SgOmpFullClause:
17282 0 : returnPointer = SgOmpFullClause::getPointerFromGlobalIndex( globalIndex ) ;
17283 0 : break ;
17284 0 : case V_SgOmpPartialClause:
17285 0 : returnPointer = SgOmpPartialClause::getPointerFromGlobalIndex( globalIndex ) ;
17286 0 : break ;
17287 0 : case V_SgOmpSizesClause:
17288 0 : returnPointer = SgOmpSizesClause::getPointerFromGlobalIndex( globalIndex ) ;
17289 0 : break ;
17290 0 : case V_SgUpirBranchField:
17291 0 : returnPointer = SgUpirBranchField::getPointerFromGlobalIndex( globalIndex ) ;
17292 0 : break ;
17293 0 : case V_SgUpirNestedLevelField:
17294 0 : returnPointer = SgUpirNestedLevelField::getPointerFromGlobalIndex( globalIndex ) ;
17295 0 : break ;
17296 0 : case V_SgUpirNestedParentField:
17297 0 : returnPointer = SgUpirNestedParentField::getPointerFromGlobalIndex( globalIndex ) ;
17298 0 : break ;
17299 0 : case V_SgUpirNestedChildField:
17300 0 : returnPointer = SgUpirNestedChildField::getPointerFromGlobalIndex( globalIndex ) ;
17301 0 : break ;
17302 0 : case V_SgUpirSyncField:
17303 0 : returnPointer = SgUpirSyncField::getPointerFromGlobalIndex( globalIndex ) ;
17304 0 : break ;
17305 0 : case V_SgUpirDataField:
17306 0 : returnPointer = SgUpirDataField::getPointerFromGlobalIndex( globalIndex ) ;
17307 0 : break ;
17308 0 : case V_SgUpirDataItemField:
17309 0 : returnPointer = SgUpirDataItemField::getPointerFromGlobalIndex( globalIndex ) ;
17310 0 : break ;
17311 0 : case V_SgUpirTargetField:
17312 0 : returnPointer = SgUpirTargetField::getPointerFromGlobalIndex( globalIndex ) ;
17313 0 : break ;
17314 0 : case V_SgOpenclAccessModeModifier:
17315 0 : returnPointer = SgOpenclAccessModeModifier::getPointerFromGlobalIndex( globalIndex ) ;
17316 0 : break ;
17317 0 : case V_SgOpenStatement:
17318 0 : returnPointer = SgOpenStatement::getPointerFromGlobalIndex( globalIndex ) ;
17319 0 : break ;
17320 0 : case V_SgOptions:
17321 0 : returnPointer = SgOptions::getPointerFromGlobalIndex( globalIndex ) ;
17322 0 : break ;
17323 498 : case V_SgOrOp:
17324 498 : returnPointer = SgOrOp::getPointerFromGlobalIndex( globalIndex ) ;
17325 498 : break ;
17326 0 : case V_SgParameterStatement:
17327 0 : returnPointer = SgParameterStatement::getPointerFromGlobalIndex( globalIndex ) ;
17328 0 : break ;
17329 0 : case V_SgPartialFunctionModifierType:
17330 0 : returnPointer = SgPartialFunctionModifierType::getPointerFromGlobalIndex( globalIndex ) ;
17331 0 : break ;
17332 0 : case V_SgPartialFunctionType:
17333 0 : returnPointer = SgPartialFunctionType::getPointerFromGlobalIndex( globalIndex ) ;
17334 0 : break ;
17335 0 : case V_SgPassStatement:
17336 0 : returnPointer = SgPassStatement::getPointerFromGlobalIndex( globalIndex ) ;
17337 0 : break ;
17338 174 : case V_SgPlusAssignOp:
17339 174 : returnPointer = SgPlusAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
17340 174 : break ;
17341 655 : case V_SgPlusPlusOp:
17342 655 : returnPointer = SgPlusPlusOp::getPointerFromGlobalIndex( globalIndex ) ;
17343 655 : break ;
17344 756 : case V_SgPntrArrRefExp:
17345 756 : returnPointer = SgPntrArrRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17346 756 : break ;
17347 0 : case V_SgPointerAssignOp:
17348 0 : returnPointer = SgPointerAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
17349 0 : break ;
17350 1920 : case V_SgPointerDerefExp:
17351 1920 : returnPointer = SgPointerDerefExp::getPointerFromGlobalIndex( globalIndex ) ;
17352 1920 : break ;
17353 108 : case V_SgPointerMemberType:
17354 108 : returnPointer = SgPointerMemberType::getPointerFromGlobalIndex( globalIndex ) ;
17355 108 : break ;
17356 12173 : case V_SgPointerType:
17357 12173 : returnPointer = SgPointerType::getPointerFromGlobalIndex( globalIndex ) ;
17358 12173 : break ;
17359 0 : case V_SgPowerOp:
17360 0 : returnPointer = SgPowerOp::getPointerFromGlobalIndex( globalIndex ) ;
17361 0 : break ;
17362 291 : case V_SgPragma:
17363 291 : returnPointer = SgPragma::getPointerFromGlobalIndex( globalIndex ) ;
17364 291 : break ;
17365 582 : case V_SgPragmaDeclaration:
17366 582 : returnPointer = SgPragmaDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17367 582 : break ;
17368 0 : case V_SgPrintStatement:
17369 0 : returnPointer = SgPrintStatement::getPointerFromGlobalIndex( globalIndex ) ;
17370 0 : break ;
17371 0 : case V_SgProcedureHeaderStatement:
17372 0 : returnPointer = SgProcedureHeaderStatement::getPointerFromGlobalIndex( globalIndex ) ;
17373 0 : break ;
17374 0 : case V_SgProgramHeaderStatement:
17375 0 : returnPointer = SgProgramHeaderStatement::getPointerFromGlobalIndex( globalIndex ) ;
17376 0 : break ;
17377 10 : case V_SgProject:
17378 10 : returnPointer = SgProject::getPointerFromGlobalIndex( globalIndex ) ;
17379 10 : break ;
17380 0 : case V_SgPseudoDestructorRefExp:
17381 0 : returnPointer = SgPseudoDestructorRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17382 0 : break ;
17383 0 : case V_SgQualifiedName:
17384 0 : returnPointer = SgQualifiedName::getPointerFromGlobalIndex( globalIndex ) ;
17385 0 : break ;
17386 0 : case V_SgQualifiedNameType:
17387 0 : returnPointer = SgQualifiedNameType::getPointerFromGlobalIndex( globalIndex ) ;
17388 0 : break ;
17389 0 : case V_SgRangeExp:
17390 0 : returnPointer = SgRangeExp::getPointerFromGlobalIndex( globalIndex ) ;
17391 0 : break ;
17392 0 : case V_SgRangeBasedForStatement:
17393 0 : returnPointer = SgRangeBasedForStatement::getPointerFromGlobalIndex( globalIndex ) ;
17394 0 : break ;
17395 0 : case V_SgReadStatement:
17396 0 : returnPointer = SgReadStatement::getPointerFromGlobalIndex( globalIndex ) ;
17397 0 : break ;
17398 0 : case V_SgRealPartOp:
17399 0 : returnPointer = SgRealPartOp::getPointerFromGlobalIndex( globalIndex ) ;
17400 0 : break ;
17401 0 : case V_SgRefExp:
17402 0 : returnPointer = SgRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17403 0 : break ;
17404 9624 : case V_SgReferenceType:
17405 9624 : returnPointer = SgReferenceType::getPointerFromGlobalIndex( globalIndex ) ;
17406 9624 : break ;
17407 0 : case V_SgRenamePair:
17408 0 : returnPointer = SgRenamePair::getPointerFromGlobalIndex( globalIndex ) ;
17409 0 : break ;
17410 0 : case V_SgRenameSymbol:
17411 0 : returnPointer = SgRenameSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17412 0 : break ;
17413 5706 : case V_SgReturnStmt:
17414 5706 : returnPointer = SgReturnStmt::getPointerFromGlobalIndex( globalIndex ) ;
17415 5706 : break ;
17416 0 : case V_SgRewindStatement:
17417 0 : returnPointer = SgRewindStatement::getPointerFromGlobalIndex( globalIndex ) ;
17418 0 : break ;
17419 12 : case V_SgRshiftAssignOp:
17420 12 : returnPointer = SgRshiftAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
17421 12 : break ;
17422 48 : case V_SgRshiftOp:
17423 48 : returnPointer = SgRshiftOp::getPointerFromGlobalIndex( globalIndex ) ;
17424 48 : break ;
17425 1232 : case V_SgRvalueReferenceType:
17426 1232 : returnPointer = SgRvalueReferenceType::getPointerFromGlobalIndex( globalIndex ) ;
17427 1232 : break ;
17428 0 : case V_SgScopeOp:
17429 0 : returnPointer = SgScopeOp::getPointerFromGlobalIndex( globalIndex ) ;
17430 0 : break ;
17431 0 : case V_SgScopeStatement:
17432 0 : returnPointer = SgScopeStatement::getPointerFromGlobalIndex( globalIndex ) ;
17433 0 : break ;
17434 0 : case V_SgSequenceStatement:
17435 0 : returnPointer = SgSequenceStatement::getPointerFromGlobalIndex( globalIndex ) ;
17436 0 : break ;
17437 0 : case V_SgSetComprehension:
17438 0 : returnPointer = SgSetComprehension::getPointerFromGlobalIndex( globalIndex ) ;
17439 0 : break ;
17440 0 : case V_SgShortVal:
17441 0 : returnPointer = SgShortVal::getPointerFromGlobalIndex( globalIndex ) ;
17442 0 : break ;
17443 0 : case V_SgSIMDBinaryOp:
17444 0 : returnPointer = SgSIMDBinaryOp::getPointerFromGlobalIndex( globalIndex ) ;
17445 0 : break ;
17446 0 : case V_SgSIMDAddOp:
17447 0 : returnPointer = SgSIMDAddOp::getPointerFromGlobalIndex( globalIndex ) ;
17448 0 : break ;
17449 0 : case V_SgSIMDSubOp:
17450 0 : returnPointer = SgSIMDSubOp::getPointerFromGlobalIndex( globalIndex ) ;
17451 0 : break ;
17452 0 : case V_SgSIMDMulOp:
17453 0 : returnPointer = SgSIMDMulOp::getPointerFromGlobalIndex( globalIndex ) ;
17454 0 : break ;
17455 0 : case V_SgSIMDDivOp:
17456 0 : returnPointer = SgSIMDDivOp::getPointerFromGlobalIndex( globalIndex ) ;
17457 0 : break ;
17458 0 : case V_SgSIMDFmaOp:
17459 0 : returnPointer = SgSIMDFmaOp::getPointerFromGlobalIndex( globalIndex ) ;
17460 0 : break ;
17461 0 : case V_SgSIMDLoad:
17462 0 : returnPointer = SgSIMDLoad::getPointerFromGlobalIndex( globalIndex ) ;
17463 0 : break ;
17464 0 : case V_SgSIMDBroadcast:
17465 0 : returnPointer = SgSIMDBroadcast::getPointerFromGlobalIndex( globalIndex ) ;
17466 0 : break ;
17467 0 : case V_SgSIMDStore:
17468 0 : returnPointer = SgSIMDStore::getPointerFromGlobalIndex( globalIndex ) ;
17469 0 : break ;
17470 0 : case V_SgSIMDPartialStore:
17471 0 : returnPointer = SgSIMDPartialStore::getPointerFromGlobalIndex( globalIndex ) ;
17472 0 : break ;
17473 0 : case V_SgSIMDScalarStore:
17474 0 : returnPointer = SgSIMDScalarStore::getPointerFromGlobalIndex( globalIndex ) ;
17475 0 : break ;
17476 0 : case V_SgSIMDGather:
17477 0 : returnPointer = SgSIMDGather::getPointerFromGlobalIndex( globalIndex ) ;
17478 0 : break ;
17479 0 : case V_SgSIMDExplicitGather:
17480 0 : returnPointer = SgSIMDExplicitGather::getPointerFromGlobalIndex( globalIndex ) ;
17481 0 : break ;
17482 0 : case V_SgSIMDScatter:
17483 0 : returnPointer = SgSIMDScatter::getPointerFromGlobalIndex( globalIndex ) ;
17484 0 : break ;
17485 396 : case V_SgSizeOfOp:
17486 396 : returnPointer = SgSizeOfOp::getPointerFromGlobalIndex( globalIndex ) ;
17487 396 : break ;
17488 20 : case V_SgAlignOfOp:
17489 20 : returnPointer = SgAlignOfOp::getPointerFromGlobalIndex( globalIndex ) ;
17490 20 : break ;
17491 624 : case V_SgSourceFile:
17492 624 : returnPointer = SgSourceFile::getPointerFromGlobalIndex( globalIndex ) ;
17493 624 : break ;
17494 0 : case V_SgSpaceshipOp:
17495 0 : returnPointer = SgSpaceshipOp::getPointerFromGlobalIndex( globalIndex ) ;
17496 0 : break ;
17497 0 : case V_SgSpawnStmt:
17498 0 : returnPointer = SgSpawnStmt::getPointerFromGlobalIndex( globalIndex ) ;
17499 0 : break ;
17500 0 : case V_SgSyncAllStatement:
17501 0 : returnPointer = SgSyncAllStatement::getPointerFromGlobalIndex( globalIndex ) ;
17502 0 : break ;
17503 0 : case V_SgSyncImagesStatement:
17504 0 : returnPointer = SgSyncImagesStatement::getPointerFromGlobalIndex( globalIndex ) ;
17505 0 : break ;
17506 0 : case V_SgSyncMemoryStatement:
17507 0 : returnPointer = SgSyncMemoryStatement::getPointerFromGlobalIndex( globalIndex ) ;
17508 0 : break ;
17509 0 : case V_SgSyncTeamStatement:
17510 0 : returnPointer = SgSyncTeamStatement::getPointerFromGlobalIndex( globalIndex ) ;
17511 0 : break ;
17512 0 : case V_SgLockStatement:
17513 0 : returnPointer = SgLockStatement::getPointerFromGlobalIndex( globalIndex ) ;
17514 0 : break ;
17515 0 : case V_SgUnlockStatement:
17516 0 : returnPointer = SgUnlockStatement::getPointerFromGlobalIndex( globalIndex ) ;
17517 0 : break ;
17518 0 : case V_SgProcessControlStatement:
17519 0 : returnPointer = SgProcessControlStatement::getPointerFromGlobalIndex( globalIndex ) ;
17520 0 : break ;
17521 0 : case V_SgSpecialFunctionModifier:
17522 0 : returnPointer = SgSpecialFunctionModifier::getPointerFromGlobalIndex( globalIndex ) ;
17523 0 : break ;
17524 0 : case V_SgStatement:
17525 0 : returnPointer = SgStatement::getPointerFromGlobalIndex( globalIndex ) ;
17526 0 : break ;
17527 70 : case V_SgStaticAssertionDeclaration:
17528 70 : returnPointer = SgStaticAssertionDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17529 70 : break ;
17530 0 : case V_SgStmtDeclarationStatement:
17531 0 : returnPointer = SgStmtDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
17532 0 : break ;
17533 0 : case V_SgStatementExpression:
17534 0 : returnPointer = SgStatementExpression::getPointerFromGlobalIndex( globalIndex ) ;
17535 0 : break ;
17536 0 : case V_SgStatementFunctionStatement:
17537 0 : returnPointer = SgStatementFunctionStatement::getPointerFromGlobalIndex( globalIndex ) ;
17538 0 : break ;
17539 55225 : case V_SgStorageModifier:
17540 55225 : returnPointer = SgStorageModifier::getPointerFromGlobalIndex( globalIndex ) ;
17541 55225 : break ;
17542 0 : case V_SgStringConversion:
17543 0 : returnPointer = SgStringConversion::getPointerFromGlobalIndex( globalIndex ) ;
17544 0 : break ;
17545 0 : case V_SgStringKeyedBidirectionalGraph:
17546 0 : returnPointer = SgStringKeyedBidirectionalGraph::getPointerFromGlobalIndex( globalIndex ) ;
17547 0 : break ;
17548 328 : case V_SgStringVal:
17549 328 : returnPointer = SgStringVal::getPointerFromGlobalIndex( globalIndex ) ;
17550 328 : break ;
17551 0 : case V_SgStructureModifier:
17552 0 : returnPointer = SgStructureModifier::getPointerFromGlobalIndex( globalIndex ) ;
17553 0 : break ;
17554 0 : case V_SgSubscriptExpression:
17555 0 : returnPointer = SgSubscriptExpression::getPointerFromGlobalIndex( globalIndex ) ;
17556 0 : break ;
17557 1266 : case V_SgSubtractOp:
17558 1266 : returnPointer = SgSubtractOp::getPointerFromGlobalIndex( globalIndex ) ;
17559 1266 : break ;
17560 0 : case V_SgSupport:
17561 0 : returnPointer = SgSupport::getPointerFromGlobalIndex( globalIndex ) ;
17562 0 : break ;
17563 0 : case V_SgSwitchStatement:
17564 0 : returnPointer = SgSwitchStatement::getPointerFromGlobalIndex( globalIndex ) ;
17565 0 : break ;
17566 0 : case V_SgSymbol:
17567 0 : returnPointer = SgSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17568 0 : break ;
17569 72436 : case V_SgSymbolTable:
17570 72436 : returnPointer = SgSymbolTable::getPointerFromGlobalIndex( globalIndex ) ;
17571 72436 : break ;
17572 9002 : case V_SgTemplateArgument:
17573 9002 : returnPointer = SgTemplateArgument::getPointerFromGlobalIndex( globalIndex ) ;
17574 9002 : break ;
17575 0 : case V_SgTemplateArgumentList:
17576 0 : returnPointer = SgTemplateArgumentList::getPointerFromGlobalIndex( globalIndex ) ;
17577 0 : break ;
17578 0 : case V_SgTemplateDeclaration:
17579 0 : returnPointer = SgTemplateDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17580 0 : break ;
17581 12056 : case V_SgTemplateClassDeclaration:
17582 12056 : returnPointer = SgTemplateClassDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17583 12056 : break ;
17584 2762 : case V_SgTemplateClassSymbol:
17585 2762 : returnPointer = SgTemplateClassSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17586 2762 : break ;
17587 7172 : case V_SgTemplateFunctionDeclaration:
17588 7172 : returnPointer = SgTemplateFunctionDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17589 7172 : break ;
17590 900 : case V_SgTemplateFunctionRefExp:
17591 900 : returnPointer = SgTemplateFunctionRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17592 900 : break ;
17593 904 : case V_SgTemplateFunctionSymbol:
17594 904 : returnPointer = SgTemplateFunctionSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17595 904 : break ;
17596 20539 : case V_SgTemplateMemberFunctionDeclaration:
17597 20539 : returnPointer = SgTemplateMemberFunctionDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17598 20539 : break ;
17599 2952 : case V_SgTemplateMemberFunctionRefExp:
17600 2952 : returnPointer = SgTemplateMemberFunctionRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17601 2952 : break ;
17602 2015 : case V_SgTemplateMemberFunctionSymbol:
17603 2015 : returnPointer = SgTemplateMemberFunctionSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17604 2015 : break ;
17605 942 : case V_SgTemplateTypedefDeclaration:
17606 942 : returnPointer = SgTemplateTypedefDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17607 942 : break ;
17608 283 : case V_SgTemplateTypedefSymbol:
17609 283 : returnPointer = SgTemplateTypedefSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17610 283 : break ;
17611 558 : case V_SgTemplateVariableDeclaration:
17612 558 : returnPointer = SgTemplateVariableDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17613 558 : break ;
17614 533 : case V_SgTemplateVariableSymbol:
17615 533 : returnPointer = SgTemplateVariableSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17616 533 : break ;
17617 7932 : case V_SgTemplateClassDefinition:
17618 7932 : returnPointer = SgTemplateClassDefinition::getPointerFromGlobalIndex( globalIndex ) ;
17619 7932 : break ;
17620 2528 : case V_SgTemplateFunctionDefinition:
17621 2528 : returnPointer = SgTemplateFunctionDefinition::getPointerFromGlobalIndex( globalIndex ) ;
17622 2528 : break ;
17623 10595 : case V_SgTemplateInstantiationDecl:
17624 10595 : returnPointer = SgTemplateInstantiationDecl::getPointerFromGlobalIndex( globalIndex ) ;
17625 10595 : break ;
17626 15069 : case V_SgTemplateInstantiationDefn:
17627 15069 : returnPointer = SgTemplateInstantiationDefn::getPointerFromGlobalIndex( globalIndex ) ;
17628 15069 : break ;
17629 744 : case V_SgTemplateInstantiationDirectiveStatement:
17630 744 : returnPointer = SgTemplateInstantiationDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
17631 744 : break ;
17632 2777 : case V_SgTemplateInstantiationFunctionDecl:
17633 2777 : returnPointer = SgTemplateInstantiationFunctionDecl::getPointerFromGlobalIndex( globalIndex ) ;
17634 2777 : break ;
17635 16664 : case V_SgTemplateInstantiationMemberFunctionDecl:
17636 16664 : returnPointer = SgTemplateInstantiationMemberFunctionDecl::getPointerFromGlobalIndex( globalIndex ) ;
17637 16664 : break ;
17638 511 : case V_SgTemplateInstantiationTypedefDeclaration:
17639 511 : returnPointer = SgTemplateInstantiationTypedefDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17640 511 : break ;
17641 3892 : case V_SgTemplateParameter:
17642 3892 : returnPointer = SgTemplateParameter::getPointerFromGlobalIndex( globalIndex ) ;
17643 3892 : break ;
17644 0 : case V_SgTemplateParameterVal:
17645 0 : returnPointer = SgTemplateParameterVal::getPointerFromGlobalIndex( globalIndex ) ;
17646 0 : break ;
17647 0 : case V_SgTemplateParameterList:
17648 0 : returnPointer = SgTemplateParameterList::getPointerFromGlobalIndex( globalIndex ) ;
17649 0 : break ;
17650 0 : case V_SgTemplateSymbol:
17651 0 : returnPointer = SgTemplateSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17652 0 : break ;
17653 0 : case V_SgTemplateType:
17654 0 : returnPointer = SgTemplateType::getPointerFromGlobalIndex( globalIndex ) ;
17655 0 : break ;
17656 4944 : case V_SgThisExp:
17657 4944 : returnPointer = SgThisExp::getPointerFromGlobalIndex( globalIndex ) ;
17658 4944 : break ;
17659 219 : case V_SgTypeTraitBuiltinOperator:
17660 219 : returnPointer = SgTypeTraitBuiltinOperator::getPointerFromGlobalIndex( globalIndex ) ;
17661 219 : break ;
17662 0 : case V_SgSuperExp:
17663 0 : returnPointer = SgSuperExp::getPointerFromGlobalIndex( globalIndex ) ;
17664 0 : break ;
17665 210 : case V_SgThrowOp:
17666 210 : returnPointer = SgThrowOp::getPointerFromGlobalIndex( globalIndex ) ;
17667 210 : break ;
17668 0 : case V_SgToken:
17669 0 : returnPointer = SgToken::getPointerFromGlobalIndex( globalIndex ) ;
17670 0 : break ;
17671 271 : case V_SgTryStmt:
17672 271 : returnPointer = SgTryStmt::getPointerFromGlobalIndex( globalIndex ) ;
17673 271 : break ;
17674 0 : case V_SgTupleExp:
17675 0 : returnPointer = SgTupleExp::getPointerFromGlobalIndex( globalIndex ) ;
17676 0 : break ;
17677 0 : case V_SgType:
17678 0 : returnPointer = SgType::getPointerFromGlobalIndex( globalIndex ) ;
17679 0 : break ;
17680 1465 : case V_SgTypeBool:
17681 1465 : returnPointer = SgTypeBool::getPointerFromGlobalIndex( globalIndex ) ;
17682 1465 : break ;
17683 632 : case V_SgTypeChar:
17684 632 : returnPointer = SgTypeChar::getPointerFromGlobalIndex( globalIndex ) ;
17685 632 : break ;
17686 151 : case V_SgTypeChar16:
17687 151 : returnPointer = SgTypeChar16::getPointerFromGlobalIndex( globalIndex ) ;
17688 151 : break ;
17689 151 : case V_SgTypeChar32:
17690 151 : returnPointer = SgTypeChar32::getPointerFromGlobalIndex( globalIndex ) ;
17691 151 : break ;
17692 304 : case V_SgTypeComplex:
17693 304 : returnPointer = SgTypeComplex::getPointerFromGlobalIndex( globalIndex ) ;
17694 304 : break ;
17695 11 : case V_SgTypeDefault:
17696 11 : returnPointer = SgTypeDefault::getPointerFromGlobalIndex( globalIndex ) ;
17697 11 : break ;
17698 0 : case V_SgTypeExpression:
17699 0 : returnPointer = SgTypeExpression::getPointerFromGlobalIndex( globalIndex ) ;
17700 0 : break ;
17701 0 : case V_SgTypeLabel:
17702 0 : returnPointer = SgTypeLabel::getPointerFromGlobalIndex( globalIndex ) ;
17703 0 : break ;
17704 660 : case V_SgTypeDouble:
17705 660 : returnPointer = SgTypeDouble::getPointerFromGlobalIndex( globalIndex ) ;
17706 660 : break ;
17707 476 : case V_SgTypeEllipse:
17708 476 : returnPointer = SgTypeEllipse::getPointerFromGlobalIndex( globalIndex ) ;
17709 476 : break ;
17710 0 : case V_SgTypeFixed:
17711 0 : returnPointer = SgTypeFixed::getPointerFromGlobalIndex( globalIndex ) ;
17712 0 : break ;
17713 486 : case V_SgTypeFloat:
17714 486 : returnPointer = SgTypeFloat::getPointerFromGlobalIndex( globalIndex ) ;
17715 486 : break ;
17716 4 : case V_SgTypeFloat128:
17717 4 : returnPointer = SgTypeFloat128::getPointerFromGlobalIndex( globalIndex ) ;
17718 4 : break ;
17719 0 : case V_SgTypeFloat80:
17720 0 : returnPointer = SgTypeFloat80::getPointerFromGlobalIndex( globalIndex ) ;
17721 0 : break ;
17722 0 : case V_SgTypeGlobalVoid:
17723 0 : returnPointer = SgTypeGlobalVoid::getPointerFromGlobalIndex( globalIndex ) ;
17724 0 : break ;
17725 5 : case V_SgTypeIdOp:
17726 5 : returnPointer = SgTypeIdOp::getPointerFromGlobalIndex( globalIndex ) ;
17727 5 : break ;
17728 0 : case V_SgTypeImaginary:
17729 0 : returnPointer = SgTypeImaginary::getPointerFromGlobalIndex( globalIndex ) ;
17730 0 : break ;
17731 3155 : case V_SgTypeInt:
17732 3155 : returnPointer = SgTypeInt::getPointerFromGlobalIndex( globalIndex ) ;
17733 3155 : break ;
17734 386 : case V_SgTypeLong:
17735 386 : returnPointer = SgTypeLong::getPointerFromGlobalIndex( globalIndex ) ;
17736 386 : break ;
17737 522 : case V_SgTypeLongDouble:
17738 522 : returnPointer = SgTypeLongDouble::getPointerFromGlobalIndex( globalIndex ) ;
17739 522 : break ;
17740 376 : case V_SgTypeLongLong:
17741 376 : returnPointer = SgTypeLongLong::getPointerFromGlobalIndex( globalIndex ) ;
17742 376 : break ;
17743 0 : case V_SgTypeModifier:
17744 0 : returnPointer = SgTypeModifier::getPointerFromGlobalIndex( globalIndex ) ;
17745 0 : break ;
17746 0 : case V_SgTypeMatrix:
17747 0 : returnPointer = SgTypeMatrix::getPointerFromGlobalIndex( globalIndex ) ;
17748 0 : break ;
17749 0 : case V_SgTypeTuple:
17750 0 : returnPointer = SgTypeTuple::getPointerFromGlobalIndex( globalIndex ) ;
17751 0 : break ;
17752 2 : case V_SgTypeNullptr:
17753 2 : returnPointer = SgTypeNullptr::getPointerFromGlobalIndex( globalIndex ) ;
17754 2 : break ;
17755 9 : case V_SgTypeOfType:
17756 9 : returnPointer = SgTypeOfType::getPointerFromGlobalIndex( globalIndex ) ;
17757 9 : break ;
17758 140 : case V_SgTypeShort:
17759 140 : returnPointer = SgTypeShort::getPointerFromGlobalIndex( globalIndex ) ;
17760 140 : break ;
17761 22 : case V_SgTypeSigned128bitInteger:
17762 22 : returnPointer = SgTypeSigned128bitInteger::getPointerFromGlobalIndex( globalIndex ) ;
17763 22 : break ;
17764 39 : case V_SgTypeSignedChar:
17765 39 : returnPointer = SgTypeSignedChar::getPointerFromGlobalIndex( globalIndex ) ;
17766 39 : break ;
17767 7 : case V_SgTypeSignedInt:
17768 7 : returnPointer = SgTypeSignedInt::getPointerFromGlobalIndex( globalIndex ) ;
17769 7 : break ;
17770 7 : case V_SgTypeSignedLong:
17771 7 : returnPointer = SgTypeSignedLong::getPointerFromGlobalIndex( globalIndex ) ;
17772 7 : break ;
17773 3 : case V_SgTypeSignedLongLong:
17774 3 : returnPointer = SgTypeSignedLongLong::getPointerFromGlobalIndex( globalIndex ) ;
17775 3 : break ;
17776 7 : case V_SgTypeSignedShort:
17777 7 : returnPointer = SgTypeSignedShort::getPointerFromGlobalIndex( globalIndex ) ;
17778 7 : break ;
17779 0 : case V_SgTypeString:
17780 0 : returnPointer = SgTypeString::getPointerFromGlobalIndex( globalIndex ) ;
17781 0 : break ;
17782 9 : case V_SgTypeUnknown:
17783 9 : returnPointer = SgTypeUnknown::getPointerFromGlobalIndex( globalIndex ) ;
17784 9 : break ;
17785 14 : case V_SgTypeUnsigned128bitInteger:
17786 14 : returnPointer = SgTypeUnsigned128bitInteger::getPointerFromGlobalIndex( globalIndex ) ;
17787 14 : break ;
17788 135 : case V_SgTypeUnsignedChar:
17789 135 : returnPointer = SgTypeUnsignedChar::getPointerFromGlobalIndex( globalIndex ) ;
17790 135 : break ;
17791 1841 : case V_SgTypeUnsignedInt:
17792 1841 : returnPointer = SgTypeUnsignedInt::getPointerFromGlobalIndex( globalIndex ) ;
17793 1841 : break ;
17794 737 : case V_SgTypeUnsignedLong:
17795 737 : returnPointer = SgTypeUnsignedLong::getPointerFromGlobalIndex( globalIndex ) ;
17796 737 : break ;
17797 293 : case V_SgTypeUnsignedLongLong:
17798 293 : returnPointer = SgTypeUnsignedLongLong::getPointerFromGlobalIndex( globalIndex ) ;
17799 293 : break ;
17800 116 : case V_SgTypeUnsignedShort:
17801 116 : returnPointer = SgTypeUnsignedShort::getPointerFromGlobalIndex( globalIndex ) ;
17802 116 : break ;
17803 2684 : case V_SgTypeVoid:
17804 2684 : returnPointer = SgTypeVoid::getPointerFromGlobalIndex( globalIndex ) ;
17805 2684 : break ;
17806 312 : case V_SgTypeWchar:
17807 312 : returnPointer = SgTypeWchar::getPointerFromGlobalIndex( globalIndex ) ;
17808 312 : break ;
17809 10440 : case V_SgTypedefDeclaration:
17810 10440 : returnPointer = SgTypedefDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17811 10440 : break ;
17812 16445 : case V_SgTypedefSeq:
17813 16445 : returnPointer = SgTypedefSeq::getPointerFromGlobalIndex( globalIndex ) ;
17814 16445 : break ;
17815 3135 : case V_SgTypedefSymbol:
17816 3135 : returnPointer = SgTypedefSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17817 3135 : break ;
17818 55148 : case V_SgTypedefType:
17819 55148 : returnPointer = SgTypedefType::getPointerFromGlobalIndex( globalIndex ) ;
17820 55148 : break ;
17821 0 : case V_SgUPC_AccessModifier:
17822 0 : returnPointer = SgUPC_AccessModifier::getPointerFromGlobalIndex( globalIndex ) ;
17823 0 : break ;
17824 0 : case V_SgUnaryAddOp:
17825 0 : returnPointer = SgUnaryAddOp::getPointerFromGlobalIndex( globalIndex ) ;
17826 0 : break ;
17827 0 : case V_SgUnaryOp:
17828 0 : returnPointer = SgUnaryOp::getPointerFromGlobalIndex( globalIndex ) ;
17829 0 : break ;
17830 0 : case V_SgUndefDirectiveStatement:
17831 0 : returnPointer = SgUndefDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
17832 0 : break ;
17833 0 : case V_SgUndirectedGraphEdge:
17834 0 : returnPointer = SgUndirectedGraphEdge::getPointerFromGlobalIndex( globalIndex ) ;
17835 0 : break ;
17836 0 : case V_SgUnknownArrayOrFunctionReference:
17837 0 : returnPointer = SgUnknownArrayOrFunctionReference::getPointerFromGlobalIndex( globalIndex ) ;
17838 0 : break ;
17839 0 : case V_SgUnknownFile:
17840 0 : returnPointer = SgUnknownFile::getPointerFromGlobalIndex( globalIndex ) ;
17841 0 : break ;
17842 0 : case V_SgUnparse_Info:
17843 0 : returnPointer = SgUnparse_Info::getPointerFromGlobalIndex( globalIndex ) ;
17844 0 : break ;
17845 0 : case V_SgUnsignedCharVal:
17846 0 : returnPointer = SgUnsignedCharVal::getPointerFromGlobalIndex( globalIndex ) ;
17847 0 : break ;
17848 32 : case V_SgUnsignedIntVal:
17849 32 : returnPointer = SgUnsignedIntVal::getPointerFromGlobalIndex( globalIndex ) ;
17850 32 : break ;
17851 0 : case V_SgUnsignedLongLongIntVal:
17852 0 : returnPointer = SgUnsignedLongLongIntVal::getPointerFromGlobalIndex( globalIndex ) ;
17853 0 : break ;
17854 87 : case V_SgUnsignedLongVal:
17855 87 : returnPointer = SgUnsignedLongVal::getPointerFromGlobalIndex( globalIndex ) ;
17856 87 : break ;
17857 0 : case V_SgUnsignedShortVal:
17858 0 : returnPointer = SgUnsignedShortVal::getPointerFromGlobalIndex( globalIndex ) ;
17859 0 : break ;
17860 0 : case V_SgUpcBarrierStatement:
17861 0 : returnPointer = SgUpcBarrierStatement::getPointerFromGlobalIndex( globalIndex ) ;
17862 0 : break ;
17863 0 : case V_SgUpcBlocksizeofExpression:
17864 0 : returnPointer = SgUpcBlocksizeofExpression::getPointerFromGlobalIndex( globalIndex ) ;
17865 0 : break ;
17866 0 : case V_SgUpcElemsizeofExpression:
17867 0 : returnPointer = SgUpcElemsizeofExpression::getPointerFromGlobalIndex( globalIndex ) ;
17868 0 : break ;
17869 0 : case V_SgUpcFenceStatement:
17870 0 : returnPointer = SgUpcFenceStatement::getPointerFromGlobalIndex( globalIndex ) ;
17871 0 : break ;
17872 0 : case V_SgUpcForAllStatement:
17873 0 : returnPointer = SgUpcForAllStatement::getPointerFromGlobalIndex( globalIndex ) ;
17874 0 : break ;
17875 0 : case V_SgUpcLocalsizeofExpression:
17876 0 : returnPointer = SgUpcLocalsizeofExpression::getPointerFromGlobalIndex( globalIndex ) ;
17877 0 : break ;
17878 0 : case V_SgUpcMythread:
17879 0 : returnPointer = SgUpcMythread::getPointerFromGlobalIndex( globalIndex ) ;
17880 0 : break ;
17881 0 : case V_SgUpcNotifyStatement:
17882 0 : returnPointer = SgUpcNotifyStatement::getPointerFromGlobalIndex( globalIndex ) ;
17883 0 : break ;
17884 0 : case V_SgUpcThreads:
17885 0 : returnPointer = SgUpcThreads::getPointerFromGlobalIndex( globalIndex ) ;
17886 0 : break ;
17887 0 : case V_SgUpcWaitStatement:
17888 0 : returnPointer = SgUpcWaitStatement::getPointerFromGlobalIndex( globalIndex ) ;
17889 0 : break ;
17890 0 : case V_SgUseStatement:
17891 0 : returnPointer = SgUseStatement::getPointerFromGlobalIndex( globalIndex ) ;
17892 0 : break ;
17893 0 : case V_SgUserDefinedBinaryOp:
17894 0 : returnPointer = SgUserDefinedBinaryOp::getPointerFromGlobalIndex( globalIndex ) ;
17895 0 : break ;
17896 0 : case V_SgUserDefinedUnaryOp:
17897 0 : returnPointer = SgUserDefinedUnaryOp::getPointerFromGlobalIndex( globalIndex ) ;
17898 0 : break ;
17899 1375 : case V_SgUsingDeclarationStatement:
17900 1375 : returnPointer = SgUsingDeclarationStatement::getPointerFromGlobalIndex( globalIndex ) ;
17901 1375 : break ;
17902 5 : case V_SgUsingDirectiveStatement:
17903 5 : returnPointer = SgUsingDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
17904 5 : break ;
17905 0 : case V_SgValueExp:
17906 0 : returnPointer = SgValueExp::getPointerFromGlobalIndex( globalIndex ) ;
17907 0 : break ;
17908 0 : case V_SgVarArgCopyOp:
17909 0 : returnPointer = SgVarArgCopyOp::getPointerFromGlobalIndex( globalIndex ) ;
17910 0 : break ;
17911 0 : case V_SgVarArgEndOp:
17912 0 : returnPointer = SgVarArgEndOp::getPointerFromGlobalIndex( globalIndex ) ;
17913 0 : break ;
17914 0 : case V_SgVarArgOp:
17915 0 : returnPointer = SgVarArgOp::getPointerFromGlobalIndex( globalIndex ) ;
17916 0 : break ;
17917 0 : case V_SgVarArgStartOneOperandOp:
17918 0 : returnPointer = SgVarArgStartOneOperandOp::getPointerFromGlobalIndex( globalIndex ) ;
17919 0 : break ;
17920 0 : case V_SgVarArgStartOp:
17921 0 : returnPointer = SgVarArgStartOp::getPointerFromGlobalIndex( globalIndex ) ;
17922 0 : break ;
17923 26044 : case V_SgVarRefExp:
17924 26044 : returnPointer = SgVarRefExp::getPointerFromGlobalIndex( globalIndex ) ;
17925 26044 : break ;
17926 6505 : case V_SgVariableDeclaration:
17927 6505 : returnPointer = SgVariableDeclaration::getPointerFromGlobalIndex( globalIndex ) ;
17928 6505 : break ;
17929 4188 : case V_SgVariableDefinition:
17930 4188 : returnPointer = SgVariableDefinition::getPointerFromGlobalIndex( globalIndex ) ;
17931 4188 : break ;
17932 11268 : case V_SgVariableSymbol:
17933 11268 : returnPointer = SgVariableSymbol::getPointerFromGlobalIndex( globalIndex ) ;
17934 11268 : break ;
17935 0 : case V_SgVariantExpression:
17936 0 : returnPointer = SgVariantExpression::getPointerFromGlobalIndex( globalIndex ) ;
17937 0 : break ;
17938 0 : case V_SgVariantStatement:
17939 0 : returnPointer = SgVariantStatement::getPointerFromGlobalIndex( globalIndex ) ;
17940 0 : break ;
17941 0 : case V_SgVoidVal:
17942 0 : returnPointer = SgVoidVal::getPointerFromGlobalIndex( globalIndex ) ;
17943 0 : break ;
17944 0 : case V_SgWaitStatement:
17945 0 : returnPointer = SgWaitStatement::getPointerFromGlobalIndex( globalIndex ) ;
17946 0 : break ;
17947 0 : case V_SgWarningDirectiveStatement:
17948 0 : returnPointer = SgWarningDirectiveStatement::getPointerFromGlobalIndex( globalIndex ) ;
17949 0 : break ;
17950 0 : case V_SgWithStatement:
17951 0 : returnPointer = SgWithStatement::getPointerFromGlobalIndex( globalIndex ) ;
17952 0 : break ;
17953 0 : case V_SgWcharVal:
17954 0 : returnPointer = SgWcharVal::getPointerFromGlobalIndex( globalIndex ) ;
17955 0 : break ;
17956 0 : case V_SgWhereStatement:
17957 0 : returnPointer = SgWhereStatement::getPointerFromGlobalIndex( globalIndex ) ;
17958 0 : break ;
17959 335 : case V_SgWhileStmt:
17960 335 : returnPointer = SgWhileStmt::getPointerFromGlobalIndex( globalIndex ) ;
17961 335 : break ;
17962 0 : case V_SgWriteStatement:
17963 0 : returnPointer = SgWriteStatement::getPointerFromGlobalIndex( globalIndex ) ;
17964 0 : break ;
17965 0 : case V_SgXorAssignOp:
17966 0 : returnPointer = SgXorAssignOp::getPointerFromGlobalIndex( globalIndex ) ;
17967 0 : break ;
17968 0 : case V_SgYieldExpression:
17969 0 : returnPointer = SgYieldExpression::getPointerFromGlobalIndex( globalIndex ) ;
17970 0 : break ;
17971 342726 : case V_Sg_File_Info:
17972 342726 : returnPointer = Sg_File_Info::getPointerFromGlobalIndex( globalIndex ) ;
17973 342726 : break ;
17974 0 : case V_SgTypeCAFTeam:
17975 0 : returnPointer = SgTypeCAFTeam::getPointerFromGlobalIndex( globalIndex ) ;
17976 0 : break ;
17977 0 : case V_SgCAFWithTeamStatement:
17978 0 : returnPointer = SgCAFWithTeamStatement::getPointerFromGlobalIndex( globalIndex ) ;
17979 0 : break ;
17980 0 : case V_SgCAFCoExpression:
17981 0 : returnPointer = SgCAFCoExpression::getPointerFromGlobalIndex( globalIndex ) ;
17982 0 : break ;
17983 0 : case V_SgCallExpression:
17984 0 : returnPointer = SgCallExpression::getPointerFromGlobalIndex( globalIndex ) ;
17985 0 : break ;
17986 0 : case V_SgTypeCrayPointer:
17987 0 : returnPointer = SgTypeCrayPointer::getPointerFromGlobalIndex( globalIndex ) ;
17988 0 : break ;
17989 0 : case V_SgClassExp:
17990 0 : returnPointer = SgClassExp::getPointerFromGlobalIndex( globalIndex ) ;
17991 0 : break ;
17992 0 : default:
17993 0 : assert ( !" Index error in getPointerFromGlobalIndex !" ) ;
17994 : break ;
17995 : }
17996 : #if FILE_IO_EXTRA_CHECK
17997 1739590 : assert ( returnPointer != NULL );
17998 : #endif
17999 : }
18000 :
18001 : /* #line 327 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
18002 :
18003 : #if DEBUG_AstFileIO_getSgClassPointerFromGlobalIndex
18004 : printf (" returnPointer = %p\n", returnPointer); // might not have been read yet
18005 : #endif
18006 :
18007 : return returnPointer;
18008 : }
18009 :
18010 :
18011 :
18012 : /* JH (01/03/2006) This mehtods steps through all memory pools and deletes all data contained in
18013 : the pools, to prepare the base for starting the memory extension for rebuilding the AST.
18014 : */
18015 0 : void AST_FILE_IO::clearAllMemoryPools( ) {
18016 0 : freepointersOfCurrentAstAreSetToGlobalIndices = false;
18017 : // JH (08/08/2006) calling delete on the roots of the stored ASTs, in order to have
18018 : // empty memory pools afterwards
18019 0 : for (unsigned long i = 0; i < vectorOfASTs.size(); ++i)
18020 : {
18021 0 : delete (vectorOfASTs[i]->getRootOfAst());
18022 : }
18023 : // JH (08/08/2006) the new version of clear memory pools has nothing to delete anymore,
18024 : // but still sets the freepointers to have a ordered linked list - maybe this method
18025 : // should now be renamed ...
18026 :
18027 0 : SgAccessModifier::clearMemoryPool( );
18028 0 : SgActualArgumentExpression::clearMemoryPool( );
18029 0 : SgAddOp::clearMemoryPool( );
18030 0 : SgAddressOfOp::clearMemoryPool( );
18031 0 : SgAggregateInitializer::clearMemoryPool( );
18032 0 : SgAliasSymbol::clearMemoryPool( );
18033 0 : SgAllocateStatement::clearMemoryPool( );
18034 0 : SgAndAssignOp::clearMemoryPool( );
18035 0 : SgAndOp::clearMemoryPool( );
18036 0 : SgArithmeticIfStatement::clearMemoryPool( );
18037 0 : SgArrayType::clearMemoryPool( );
18038 0 : SgArrowExp::clearMemoryPool( );
18039 0 : SgArrowStarOp::clearMemoryPool( );
18040 0 : SgAsmOp::clearMemoryPool( );
18041 0 : SgAsmStmt::clearMemoryPool( );
18042 0 : SgAssertStmt::clearMemoryPool( );
18043 0 : SgAssignInitializer::clearMemoryPool( );
18044 0 : SgAssignOp::clearMemoryPool( );
18045 0 : SgAssignStatement::clearMemoryPool( );
18046 0 : SgAssignedGotoStatement::clearMemoryPool( );
18047 0 : SgAssociateStatement::clearMemoryPool( );
18048 0 : SgAsteriskShapeExp::clearMemoryPool( );
18049 0 : SgAttribute::clearMemoryPool( );
18050 0 : SgAttributeSpecificationStatement::clearMemoryPool( );
18051 0 : SgAutoType::clearMemoryPool( );
18052 0 : SgAwaitExpression::clearMemoryPool( );
18053 0 : SgBackspaceStatement::clearMemoryPool( );
18054 0 : SgBaseClass::clearMemoryPool( );
18055 0 : SgExpBaseClass::clearMemoryPool( );
18056 0 : SgBaseClassModifier::clearMemoryPool( );
18057 0 : SgBasicBlock::clearMemoryPool( );
18058 0 : SgBidirectionalGraph::clearMemoryPool( );
18059 0 : SgBinaryOp::clearMemoryPool( );
18060 0 : SgBitAndOp::clearMemoryPool( );
18061 0 : SgBitAttribute::clearMemoryPool( );
18062 0 : SgBitComplementOp::clearMemoryPool( );
18063 0 : SgBitEqvOp::clearMemoryPool( );
18064 0 : SgBitOrOp::clearMemoryPool( );
18065 0 : SgBitXorOp::clearMemoryPool( );
18066 0 : SgBlockDataStatement::clearMemoryPool( );
18067 0 : SgBoolValExp::clearMemoryPool( );
18068 0 : SgBreakStmt::clearMemoryPool( );
18069 0 : SgBracedInitializer::clearMemoryPool( );
18070 0 : SgC_PreprocessorDirectiveStatement::clearMemoryPool( );
18071 0 : SgCaseOptionStmt::clearMemoryPool( );
18072 0 : SgCastExp::clearMemoryPool( );
18073 0 : SgCatchOptionStmt::clearMemoryPool( );
18074 0 : SgCatchStatementSeq::clearMemoryPool( );
18075 0 : SgCharVal::clearMemoryPool( );
18076 0 : SgChar16Val::clearMemoryPool( );
18077 0 : SgChar32Val::clearMemoryPool( );
18078 0 : SgChooseExpression::clearMemoryPool( );
18079 0 : SgClassDecl_attr::clearMemoryPool( );
18080 0 : SgClassDeclaration::clearMemoryPool( );
18081 0 : SgClassDefinition::clearMemoryPool( );
18082 0 : SgClassNameRefExp::clearMemoryPool( );
18083 0 : SgClassSymbol::clearMemoryPool( );
18084 0 : SgClassType::clearMemoryPool( );
18085 0 : SgClinkageDeclarationStatement::clearMemoryPool( );
18086 0 : SgClinkageEndStatement::clearMemoryPool( );
18087 0 : SgClinkageStartStatement::clearMemoryPool( );
18088 0 : SgCloseStatement::clearMemoryPool( );
18089 0 : SgColonShapeExp::clearMemoryPool( );
18090 0 : SgCommaOpExp::clearMemoryPool( );
18091 0 : SgCommonBlock::clearMemoryPool( );
18092 0 : SgCommonBlockObject::clearMemoryPool( );
18093 0 : SgCommonSymbol::clearMemoryPool( );
18094 0 : SgComplexVal::clearMemoryPool( );
18095 0 : SgComprehension::clearMemoryPool( );
18096 0 : SgCompoundAssignOp::clearMemoryPool( );
18097 0 : SgCompoundInitializer::clearMemoryPool( );
18098 0 : SgCompoundLiteralExp::clearMemoryPool( );
18099 0 : SgComputedGotoStatement::clearMemoryPool( );
18100 0 : SgConcatenationOp::clearMemoryPool( );
18101 0 : SgConditionalExp::clearMemoryPool( );
18102 0 : SgConjugateOp::clearMemoryPool( );
18103 0 : SgConstVolatileModifier::clearMemoryPool( );
18104 0 : SgConstructorInitializer::clearMemoryPool( );
18105 0 : SgContainsStatement::clearMemoryPool( );
18106 0 : SgContinueStmt::clearMemoryPool( );
18107 0 : SgCtorInitializerList::clearMemoryPool( );
18108 0 : SgDataStatementGroup::clearMemoryPool( );
18109 0 : SgDataStatementObject::clearMemoryPool( );
18110 0 : SgDataStatementValue::clearMemoryPool( );
18111 0 : SgDeadIfDirectiveStatement::clearMemoryPool( );
18112 0 : SgDeallocateStatement::clearMemoryPool( );
18113 0 : SgDeclarationModifier::clearMemoryPool( );
18114 0 : SgDeclarationScope::clearMemoryPool( );
18115 0 : SgDeclarationStatement::clearMemoryPool( );
18116 0 : SgDeclType::clearMemoryPool( );
18117 0 : SgDefaultOptionStmt::clearMemoryPool( );
18118 0 : SgDefaultSymbol::clearMemoryPool( );
18119 0 : SgDefineDirectiveStatement::clearMemoryPool( );
18120 0 : SgDeleteExp::clearMemoryPool( );
18121 0 : SgDerivedTypeStatement::clearMemoryPool( );
18122 0 : SgDesignatedInitializer::clearMemoryPool( );
18123 0 : SgDictionaryComprehension::clearMemoryPool( );
18124 0 : SgDictionaryExp::clearMemoryPool( );
18125 0 : SgDimensionObject::clearMemoryPool( );
18126 0 : SgDirectedGraphEdge::clearMemoryPool( );
18127 0 : SgDirectory::clearMemoryPool( );
18128 0 : SgDirectoryList::clearMemoryPool( );
18129 0 : SgDivAssignOp::clearMemoryPool( );
18130 0 : SgDivideOp::clearMemoryPool( );
18131 0 : SgDoWhileStmt::clearMemoryPool( );
18132 0 : SgDotExp::clearMemoryPool( );
18133 0 : SgDotStarOp::clearMemoryPool( );
18134 0 : SgDoubleVal::clearMemoryPool( );
18135 0 : SgElaboratedTypeModifier::clearMemoryPool( );
18136 0 : SgElementwiseOp::clearMemoryPool( );
18137 0 : SgElementwiseAddOp::clearMemoryPool( );
18138 0 : SgElementwiseDivideOp::clearMemoryPool( );
18139 0 : SgElementwiseLeftDivideOp::clearMemoryPool( );
18140 0 : SgElementwiseMultiplyOp::clearMemoryPool( );
18141 0 : SgElementwisePowerOp::clearMemoryPool( );
18142 0 : SgElementwiseSubtractOp::clearMemoryPool( );
18143 0 : SgElseDirectiveStatement::clearMemoryPool( );
18144 0 : SgElseWhereStatement::clearMemoryPool( );
18145 0 : SgElseifDirectiveStatement::clearMemoryPool( );
18146 0 : SgEmptyDeclaration::clearMemoryPool( );
18147 0 : SgEmptyDirectiveStatement::clearMemoryPool( );
18148 0 : SgEndfileStatement::clearMemoryPool( );
18149 0 : SgEndifDirectiveStatement::clearMemoryPool( );
18150 0 : SgEntryStatement::clearMemoryPool( );
18151 0 : SgEnumDeclaration::clearMemoryPool( );
18152 0 : SgEnumFieldSymbol::clearMemoryPool( );
18153 0 : SgEnumSymbol::clearMemoryPool( );
18154 0 : SgEnumType::clearMemoryPool( );
18155 0 : SgEnumVal::clearMemoryPool( );
18156 0 : SgEqualityOp::clearMemoryPool( );
18157 0 : SgEquivalenceStatement::clearMemoryPool( );
18158 0 : SgErrorDirectiveStatement::clearMemoryPool( );
18159 0 : SgExecStatement::clearMemoryPool( );
18160 0 : SgExponentiationOp::clearMemoryPool( );
18161 0 : SgExponentiationAssignOp::clearMemoryPool( );
18162 0 : SgExprListExp::clearMemoryPool( );
18163 0 : SgExprStatement::clearMemoryPool( );
18164 0 : SgExpression::clearMemoryPool( );
18165 0 : SgExpressionRoot::clearMemoryPool( );
18166 0 : SgFile::clearMemoryPool( );
18167 0 : SgFileList::clearMemoryPool( );
18168 0 : SgFloatVal::clearMemoryPool( );
18169 0 : SgFloat128Val::clearMemoryPool( );
18170 0 : SgFloat80Val::clearMemoryPool( );
18171 0 : SgFoldExpression::clearMemoryPool( );
18172 0 : SgFlushStatement::clearMemoryPool( );
18173 0 : SgForAllStatement::clearMemoryPool( );
18174 0 : SgForInitStatement::clearMemoryPool( );
18175 0 : SgForStatement::clearMemoryPool( );
18176 0 : SgFormatItem::clearMemoryPool( );
18177 0 : SgFormatItemList::clearMemoryPool( );
18178 0 : SgFormatStatement::clearMemoryPool( );
18179 0 : SgFortranDo::clearMemoryPool( );
18180 0 : SgFortranIncludeLine::clearMemoryPool( );
18181 0 : SgFortranNonblockedDo::clearMemoryPool( );
18182 0 : SgFuncDecl_attr::clearMemoryPool( );
18183 0 : SgFunctionCallExp::clearMemoryPool( );
18184 0 : SgFunctionDeclaration::clearMemoryPool( );
18185 0 : SgFunctionDefinition::clearMemoryPool( );
18186 0 : SgFunctionParameterScope::clearMemoryPool( );
18187 0 : SgFunctionModifier::clearMemoryPool( );
18188 0 : SgFunctionParameterList::clearMemoryPool( );
18189 0 : SgFunctionParameterRefExp::clearMemoryPool( );
18190 0 : SgFunctionParameterTypeList::clearMemoryPool( );
18191 0 : SgFunctionRefExp::clearMemoryPool( );
18192 0 : SgFunctionSymbol::clearMemoryPool( );
18193 0 : SgFunctionType::clearMemoryPool( );
18194 0 : SgFunctionTypeSymbol::clearMemoryPool( );
18195 0 : SgFunctionTypeTable::clearMemoryPool( );
18196 0 : SgTypeTable::clearMemoryPool( );
18197 0 : SgGlobal::clearMemoryPool( );
18198 0 : SgGotoStatement::clearMemoryPool( );
18199 0 : SgGraph::clearMemoryPool( );
18200 0 : SgGraphEdge::clearMemoryPool( );
18201 0 : SgGraphEdgeList::clearMemoryPool( );
18202 0 : SgGraphNode::clearMemoryPool( );
18203 0 : SgGraphNodeList::clearMemoryPool( );
18204 0 : SgGreaterOrEqualOp::clearMemoryPool( );
18205 0 : SgGreaterThanOp::clearMemoryPool( );
18206 0 : SgIOItemExpression::clearMemoryPool( );
18207 0 : SgIOStatement::clearMemoryPool( );
18208 0 : SgIdentDirectiveStatement::clearMemoryPool( );
18209 0 : SgIfDirectiveStatement::clearMemoryPool( );
18210 0 : SgIfStmt::clearMemoryPool( );
18211 0 : SgIfdefDirectiveStatement::clearMemoryPool( );
18212 0 : SgIfndefDirectiveStatement::clearMemoryPool( );
18213 0 : SgImageControlStatement::clearMemoryPool( );
18214 0 : SgImagPartOp::clearMemoryPool( );
18215 0 : SgImplicitStatement::clearMemoryPool( );
18216 0 : SgImpliedDo::clearMemoryPool( );
18217 0 : SgImportStatement::clearMemoryPool( );
18218 0 : SgIncidenceDirectedGraph::clearMemoryPool( );
18219 0 : SgIncidenceUndirectedGraph::clearMemoryPool( );
18220 0 : SgIncludeDirectiveStatement::clearMemoryPool( );
18221 0 : SgIncludeFile::clearMemoryPool( );
18222 0 : SgIncludeNextDirectiveStatement::clearMemoryPool( );
18223 0 : SgInitializedName::clearMemoryPool( );
18224 0 : SgInitializer::clearMemoryPool( );
18225 0 : SgInquireStatement::clearMemoryPool( );
18226 0 : SgIntKeyedBidirectionalGraph::clearMemoryPool( );
18227 0 : SgIntVal::clearMemoryPool( );
18228 0 : SgIntegerDivideOp::clearMemoryPool( );
18229 0 : SgIntegerDivideAssignOp::clearMemoryPool( );
18230 0 : SgInterfaceBody::clearMemoryPool( );
18231 0 : SgHeaderFileBody::clearMemoryPool( );
18232 0 : SgHeaderFileReport::clearMemoryPool( );
18233 0 : SgInterfaceStatement::clearMemoryPool( );
18234 0 : SgInterfaceSymbol::clearMemoryPool( );
18235 0 : SgIntrinsicSymbol::clearMemoryPool( );
18236 0 : SgIsOp::clearMemoryPool( );
18237 0 : SgIsNotOp::clearMemoryPool( );
18238 0 : SgIorAssignOp::clearMemoryPool( );
18239 0 : SgKeyDatumPair::clearMemoryPool( );
18240 0 : SgCudaKernelExecConfig::clearMemoryPool( );
18241 0 : SgCudaKernelCallExp::clearMemoryPool( );
18242 0 : SgLabelRefExp::clearMemoryPool( );
18243 0 : SgLabelStatement::clearMemoryPool( );
18244 0 : SgLabelSymbol::clearMemoryPool( );
18245 0 : SgLambdaCapture::clearMemoryPool( );
18246 0 : SgLambdaCaptureList::clearMemoryPool( );
18247 0 : SgLambdaExp::clearMemoryPool( );
18248 0 : SgLambdaRefExp::clearMemoryPool( );
18249 0 : SgLeftDivideOp::clearMemoryPool( );
18250 0 : SgLessOrEqualOp::clearMemoryPool( );
18251 0 : SgLessThanOp::clearMemoryPool( );
18252 0 : SgLineDirectiveStatement::clearMemoryPool( );
18253 0 : SgLinemarkerDirectiveStatement::clearMemoryPool( );
18254 0 : SgLinkageModifier::clearMemoryPool( );
18255 0 : SgListComprehension::clearMemoryPool( );
18256 0 : SgListExp::clearMemoryPool( );
18257 0 : SgLocatedNode::clearMemoryPool( );
18258 0 : SgLocatedNodeSupport::clearMemoryPool( );
18259 0 : SgLongDoubleVal::clearMemoryPool( );
18260 0 : SgLongIntVal::clearMemoryPool( );
18261 0 : SgLongLongIntVal::clearMemoryPool( );
18262 0 : SgLshiftAssignOp::clearMemoryPool( );
18263 0 : SgLshiftOp::clearMemoryPool( );
18264 0 : SgMagicColonExp::clearMemoryPool( );
18265 0 : SgMatrixExp::clearMemoryPool( );
18266 0 : SgMatrixTransposeOp::clearMemoryPool( );
18267 0 : SgMemberFunctionDeclaration::clearMemoryPool( );
18268 0 : SgMemberFunctionRefExp::clearMemoryPool( );
18269 0 : SgMemberFunctionSymbol::clearMemoryPool( );
18270 0 : SgMemberFunctionType::clearMemoryPool( );
18271 0 : SgMembershipOp::clearMemoryPool( );
18272 0 : SgMicrosoftAttributeDeclaration::clearMemoryPool( );
18273 0 : SgMinusAssignOp::clearMemoryPool( );
18274 0 : SgMinusMinusOp::clearMemoryPool( );
18275 0 : SgMinusOp::clearMemoryPool( );
18276 0 : SgModAssignOp::clearMemoryPool( );
18277 0 : SgModOp::clearMemoryPool( );
18278 0 : SgModifier::clearMemoryPool( );
18279 0 : SgModifierNodes::clearMemoryPool( );
18280 0 : SgModifierType::clearMemoryPool( );
18281 0 : SgModuleStatement::clearMemoryPool( );
18282 0 : SgModuleSymbol::clearMemoryPool( );
18283 0 : SgMultAssignOp::clearMemoryPool( );
18284 0 : SgMultiplyOp::clearMemoryPool( );
18285 0 : SgName::clearMemoryPool( );
18286 0 : SgNameGroup::clearMemoryPool( );
18287 0 : SgNamedType::clearMemoryPool( );
18288 0 : SgNamelistStatement::clearMemoryPool( );
18289 0 : SgNamespaceAliasDeclarationStatement::clearMemoryPool( );
18290 0 : SgNamespaceDeclarationStatement::clearMemoryPool( );
18291 0 : SgNamespaceDefinitionStatement::clearMemoryPool( );
18292 0 : SgNamespaceSymbol::clearMemoryPool( );
18293 0 : SgNaryOp::clearMemoryPool( );
18294 0 : SgNaryBooleanOp::clearMemoryPool( );
18295 0 : SgNaryComparisonOp::clearMemoryPool( );
18296 0 : SgNewExp::clearMemoryPool( );
18297 0 : SgNode::clearMemoryPool( );
18298 0 : SgNoexceptOp::clearMemoryPool( );
18299 0 : SgNotEqualOp::clearMemoryPool( );
18300 0 : SgNotOp::clearMemoryPool( );
18301 0 : SgNonMembershipOp::clearMemoryPool( );
18302 0 : SgNonrealDecl::clearMemoryPool( );
18303 0 : SgNonrealRefExp::clearMemoryPool( );
18304 0 : SgNonrealSymbol::clearMemoryPool( );
18305 0 : SgNonrealType::clearMemoryPool( );
18306 0 : SgNonrealBaseClass::clearMemoryPool( );
18307 0 : SgNullExpression::clearMemoryPool( );
18308 0 : SgNullptrValExp::clearMemoryPool( );
18309 0 : SgNullStatement::clearMemoryPool( );
18310 0 : SgNullifyStatement::clearMemoryPool( );
18311 0 : SgOmpAtomicStatement::clearMemoryPool( );
18312 0 : SgOmpBarrierStatement::clearMemoryPool( );
18313 0 : SgOmpCriticalStatement::clearMemoryPool( );
18314 0 : SgUpirFieldBodyStatement::clearMemoryPool( );
18315 0 : SgUpirBodyStatement::clearMemoryPool( );
18316 0 : SgUpirFieldStatement::clearMemoryPool( );
18317 0 : SgOmpDoStatement::clearMemoryPool( );
18318 0 : SgOmpFlushStatement::clearMemoryPool( );
18319 0 : SgOmpAllocateStatement::clearMemoryPool( );
18320 0 : SgOmpDeclareSimdStatement::clearMemoryPool( );
18321 0 : SgUpirWorksharingStatement::clearMemoryPool( );
18322 0 : SgOmpForSimdStatement::clearMemoryPool( );
18323 0 : SgOmpMasterStatement::clearMemoryPool( );
18324 0 : SgOmpTaskyieldStatement::clearMemoryPool( );
18325 0 : SgOmpMetadirectiveStatement::clearMemoryPool( );
18326 0 : SgOmpOrderedStatement::clearMemoryPool( );
18327 0 : SgOmpOrderedDependStatement::clearMemoryPool( );
18328 0 : SgUpirSpmdStatement::clearMemoryPool( );
18329 0 : SgOmpTeamsStatement::clearMemoryPool( );
18330 0 : SgOmpCancellationPointStatement::clearMemoryPool( );
18331 0 : SgOmpDeclareMapperStatement::clearMemoryPool( );
18332 0 : SgOmpCancelStatement::clearMemoryPool( );
18333 0 : SgOmpTaskgroupStatement::clearMemoryPool( );
18334 0 : SgOmpDepobjStatement::clearMemoryPool( );
18335 0 : SgOmpDistributeStatement::clearMemoryPool( );
18336 0 : SgOmpLoopStatement::clearMemoryPool( );
18337 0 : SgOmpScanStatement::clearMemoryPool( );
18338 0 : SgOmpTaskloopStatement::clearMemoryPool( );
18339 0 : SgOmpTargetEnterDataStatement::clearMemoryPool( );
18340 0 : SgOmpTargetExitDataStatement::clearMemoryPool( );
18341 0 : SgOmpSectionStatement::clearMemoryPool( );
18342 0 : SgOmpSectionsStatement::clearMemoryPool( );
18343 0 : SgOmpSingleStatement::clearMemoryPool( );
18344 0 : SgOmpTaskStatement::clearMemoryPool( );
18345 0 : SgOmpTaskwaitStatement::clearMemoryPool( );
18346 0 : SgOmpThreadprivateStatement::clearMemoryPool( );
18347 0 : SgOmpWorkshareStatement::clearMemoryPool( );
18348 0 : SgUpirTaskStatement::clearMemoryPool( );
18349 0 : SgOmpTargetDataStatement::clearMemoryPool( );
18350 0 : SgOmpTargetParallelForStatement::clearMemoryPool( );
18351 0 : SgOmpTargetUpdateStatement::clearMemoryPool( );
18352 0 : SgOmpRequiresStatement::clearMemoryPool( );
18353 0 : SgOmpTargetParallelStatement::clearMemoryPool( );
18354 0 : SgOmpTargetParallelForSimdStatement::clearMemoryPool( );
18355 0 : SgOmpTargetParallelLoopStatement::clearMemoryPool( );
18356 0 : SgOmpTargetSimdStatement::clearMemoryPool( );
18357 0 : SgOmpTargetTeamsStatement::clearMemoryPool( );
18358 0 : SgOmpTargetTeamsDistributeStatement::clearMemoryPool( );
18359 0 : SgOmpTargetTeamsDistributeSimdStatement::clearMemoryPool( );
18360 0 : SgOmpTargetTeamsLoopStatement::clearMemoryPool( );
18361 0 : SgOmpTargetTeamsDistributeParallelForStatement::clearMemoryPool( );
18362 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::clearMemoryPool( );
18363 0 : SgOmpDistributeSimdStatement::clearMemoryPool( );
18364 0 : SgOmpDistributeParallelForStatement::clearMemoryPool( );
18365 0 : SgOmpDistributeParallelForSimdStatement::clearMemoryPool( );
18366 0 : SgOmpTaskloopSimdStatement::clearMemoryPool( );
18367 0 : SgOmpMasterTaskloopSimdStatement::clearMemoryPool( );
18368 0 : SgOmpParallelMasterTaskloopStatement::clearMemoryPool( );
18369 0 : SgOmpParallelMasterTaskloopSimdStatement::clearMemoryPool( );
18370 0 : SgOmpTeamsDistributeStatement::clearMemoryPool( );
18371 0 : SgOmpTeamsDistributeSimdStatement::clearMemoryPool( );
18372 0 : SgOmpTeamsDistributeParallelForStatement::clearMemoryPool( );
18373 0 : SgOmpTeamsDistributeParallelForSimdStatement::clearMemoryPool( );
18374 0 : SgOmpTeamsLoopStatement::clearMemoryPool( );
18375 0 : SgOmpParallelLoopStatement::clearMemoryPool( );
18376 0 : SgOmpParallelMasterStatement::clearMemoryPool( );
18377 0 : SgOmpMasterTaskloopStatement::clearMemoryPool( );
18378 0 : SgOmpUnrollStatement::clearMemoryPool( );
18379 0 : SgOmpTileStatement::clearMemoryPool( );
18380 0 : SgUpirSimdStatement::clearMemoryPool( );
18381 0 : SgUpirBaseStatement::clearMemoryPool( );
18382 0 : SgUpirLoopStatement::clearMemoryPool( );
18383 0 : SgUpirLoopParallelStatement::clearMemoryPool( );
18384 0 : SgUpirSyncStatement::clearMemoryPool( );
18385 0 : SgOmpClause::clearMemoryPool( );
18386 0 : SgOmpAllocateClause::clearMemoryPool( );
18387 0 : SgOmpAllocatorClause::clearMemoryPool( );
18388 0 : SgOmpUsesAllocatorsClause::clearMemoryPool( );
18389 0 : SgOmpUsesAllocatorsDefination::clearMemoryPool( );
18390 0 : SgOmpToClause::clearMemoryPool( );
18391 0 : SgOmpFromClause::clearMemoryPool( );
18392 0 : SgOmpThreadsClause::clearMemoryPool( );
18393 0 : SgOmpSimdClause::clearMemoryPool( );
18394 0 : SgOmpBeginClause::clearMemoryPool( );
18395 0 : SgOmpCollapseClause::clearMemoryPool( );
18396 0 : SgOmpCopyinClause::clearMemoryPool( );
18397 0 : SgOmpCopyprivateClause::clearMemoryPool( );
18398 0 : SgOmpDefaultClause::clearMemoryPool( );
18399 0 : SgOmpEndClause::clearMemoryPool( );
18400 0 : SgOmpExpressionClause::clearMemoryPool( );
18401 0 : SgOmpFirstprivateClause::clearMemoryPool( );
18402 0 : SgOmpIfClause::clearMemoryPool( );
18403 0 : SgOmpFinalClause::clearMemoryPool( );
18404 0 : SgOmpPriorityClause::clearMemoryPool( );
18405 0 : SgOmpDeviceClause::clearMemoryPool( );
18406 0 : SgOmpLastprivateClause::clearMemoryPool( );
18407 0 : SgOmpNowaitClause::clearMemoryPool( );
18408 0 : SgOmpReadClause::clearMemoryPool( );
18409 0 : SgOmpWriteClause::clearMemoryPool( );
18410 0 : SgOmpUpdateClause::clearMemoryPool( );
18411 0 : SgOmpDepobjUpdateClause::clearMemoryPool( );
18412 0 : SgOmpDestroyClause::clearMemoryPool( );
18413 0 : SgOmpCaptureClause::clearMemoryPool( );
18414 0 : SgOmpSeqCstClause::clearMemoryPool( );
18415 0 : SgOmpAcqRelClause::clearMemoryPool( );
18416 0 : SgOmpReleaseClause::clearMemoryPool( );
18417 0 : SgOmpAcquireClause::clearMemoryPool( );
18418 0 : SgOmpReverseOffloadClause::clearMemoryPool( );
18419 0 : SgOmpUnifiedAddressClause::clearMemoryPool( );
18420 0 : SgOmpUnifiedSharedMemoryClause::clearMemoryPool( );
18421 0 : SgOmpDynamicAllocatorsClause::clearMemoryPool( );
18422 0 : SgOmpAtomicDefaultMemOrderClause::clearMemoryPool( );
18423 0 : SgOmpExtImplementationDefinedRequirementClause::clearMemoryPool( );
18424 0 : SgOmpRelaxedClause::clearMemoryPool( );
18425 0 : SgOmpParallelClause::clearMemoryPool( );
18426 0 : SgOmpSectionsClause::clearMemoryPool( );
18427 0 : SgOmpForClause::clearMemoryPool( );
18428 0 : SgOmpTaskgroupClause::clearMemoryPool( );
18429 0 : SgUpirNumUnitsField::clearMemoryPool( );
18430 0 : SgOmpNumTeamsClause::clearMemoryPool( );
18431 0 : SgOmpGrainsizeClause::clearMemoryPool( );
18432 0 : SgOmpDetachClause::clearMemoryPool( );
18433 0 : SgOmpNumTasksClause::clearMemoryPool( );
18434 0 : SgOmpNogroupClause::clearMemoryPool( );
18435 0 : SgOmpHintClause::clearMemoryPool( );
18436 0 : SgOmpOrderClause::clearMemoryPool( );
18437 0 : SgOmpDistScheduleClause::clearMemoryPool( );
18438 0 : SgOmpBindClause::clearMemoryPool( );
18439 0 : SgOmpNontemporalClause::clearMemoryPool( );
18440 0 : SgOmpInclusiveClause::clearMemoryPool( );
18441 0 : SgOmpExclusiveClause::clearMemoryPool( );
18442 0 : SgOmpIsDevicePtrClause::clearMemoryPool( );
18443 0 : SgOmpUseDevicePtrClause::clearMemoryPool( );
18444 0 : SgOmpUseDeviceAddrClause::clearMemoryPool( );
18445 0 : SgOmpThreadLimitClause::clearMemoryPool( );
18446 0 : SgOmpOrderedClause::clearMemoryPool( );
18447 0 : SgOmpPrivateClause::clearMemoryPool( );
18448 0 : SgOmpReductionClause::clearMemoryPool( );
18449 0 : SgOmpInReductionClause::clearMemoryPool( );
18450 0 : SgOmpTaskReductionClause::clearMemoryPool( );
18451 0 : SgOmpDefaultmapClause::clearMemoryPool( );
18452 0 : SgOmpScheduleClause::clearMemoryPool( );
18453 0 : SgOmpSharedClause::clearMemoryPool( );
18454 0 : SgOmpUntiedClause::clearMemoryPool( );
18455 0 : SgOmpMergeableClause::clearMemoryPool( );
18456 0 : SgOmpVariablesClause::clearMemoryPool( );
18457 0 : SgOmpMapClause::clearMemoryPool( );
18458 0 : SgOmpSafelenClause::clearMemoryPool( );
18459 0 : SgOmpSimdlenClause::clearMemoryPool( );
18460 0 : SgOmpLinearClause::clearMemoryPool( );
18461 0 : SgOmpUniformClause::clearMemoryPool( );
18462 0 : SgOmpAlignedClause::clearMemoryPool( );
18463 0 : SgOmpProcBindClause::clearMemoryPool( );
18464 0 : SgOmpAtomicClause::clearMemoryPool( );
18465 0 : SgOmpInbranchClause::clearMemoryPool( );
18466 0 : SgOmpNotinbranchClause::clearMemoryPool( );
18467 0 : SgOmpDependClause::clearMemoryPool( );
18468 0 : SgOmpAffinityClause::clearMemoryPool( );
18469 0 : SgOmpWhenClause::clearMemoryPool( );
18470 0 : SgOmpFullClause::clearMemoryPool( );
18471 0 : SgOmpPartialClause::clearMemoryPool( );
18472 0 : SgOmpSizesClause::clearMemoryPool( );
18473 0 : SgUpirBranchField::clearMemoryPool( );
18474 0 : SgUpirNestedLevelField::clearMemoryPool( );
18475 0 : SgUpirNestedParentField::clearMemoryPool( );
18476 0 : SgUpirNestedChildField::clearMemoryPool( );
18477 0 : SgUpirSyncField::clearMemoryPool( );
18478 0 : SgUpirDataField::clearMemoryPool( );
18479 0 : SgUpirDataItemField::clearMemoryPool( );
18480 0 : SgUpirTargetField::clearMemoryPool( );
18481 0 : SgOpenclAccessModeModifier::clearMemoryPool( );
18482 0 : SgOpenStatement::clearMemoryPool( );
18483 0 : SgOptions::clearMemoryPool( );
18484 0 : SgOrOp::clearMemoryPool( );
18485 0 : SgParameterStatement::clearMemoryPool( );
18486 0 : SgPartialFunctionModifierType::clearMemoryPool( );
18487 0 : SgPartialFunctionType::clearMemoryPool( );
18488 0 : SgPassStatement::clearMemoryPool( );
18489 0 : SgPlusAssignOp::clearMemoryPool( );
18490 0 : SgPlusPlusOp::clearMemoryPool( );
18491 0 : SgPntrArrRefExp::clearMemoryPool( );
18492 0 : SgPointerAssignOp::clearMemoryPool( );
18493 0 : SgPointerDerefExp::clearMemoryPool( );
18494 0 : SgPointerMemberType::clearMemoryPool( );
18495 0 : SgPointerType::clearMemoryPool( );
18496 0 : SgPowerOp::clearMemoryPool( );
18497 0 : SgPragma::clearMemoryPool( );
18498 0 : SgPragmaDeclaration::clearMemoryPool( );
18499 0 : SgPrintStatement::clearMemoryPool( );
18500 0 : SgProcedureHeaderStatement::clearMemoryPool( );
18501 0 : SgProgramHeaderStatement::clearMemoryPool( );
18502 0 : SgProject::clearMemoryPool( );
18503 0 : SgPseudoDestructorRefExp::clearMemoryPool( );
18504 0 : SgQualifiedName::clearMemoryPool( );
18505 0 : SgQualifiedNameType::clearMemoryPool( );
18506 0 : SgRangeExp::clearMemoryPool( );
18507 0 : SgRangeBasedForStatement::clearMemoryPool( );
18508 0 : SgReadStatement::clearMemoryPool( );
18509 0 : SgRealPartOp::clearMemoryPool( );
18510 0 : SgRefExp::clearMemoryPool( );
18511 0 : SgReferenceType::clearMemoryPool( );
18512 0 : SgRenamePair::clearMemoryPool( );
18513 0 : SgRenameSymbol::clearMemoryPool( );
18514 0 : SgReturnStmt::clearMemoryPool( );
18515 0 : SgRewindStatement::clearMemoryPool( );
18516 0 : SgRshiftAssignOp::clearMemoryPool( );
18517 0 : SgRshiftOp::clearMemoryPool( );
18518 0 : SgRvalueReferenceType::clearMemoryPool( );
18519 0 : SgScopeOp::clearMemoryPool( );
18520 0 : SgScopeStatement::clearMemoryPool( );
18521 0 : SgSequenceStatement::clearMemoryPool( );
18522 0 : SgSetComprehension::clearMemoryPool( );
18523 0 : SgShortVal::clearMemoryPool( );
18524 0 : SgSIMDBinaryOp::clearMemoryPool( );
18525 0 : SgSIMDAddOp::clearMemoryPool( );
18526 0 : SgSIMDSubOp::clearMemoryPool( );
18527 0 : SgSIMDMulOp::clearMemoryPool( );
18528 0 : SgSIMDDivOp::clearMemoryPool( );
18529 0 : SgSIMDFmaOp::clearMemoryPool( );
18530 0 : SgSIMDLoad::clearMemoryPool( );
18531 0 : SgSIMDBroadcast::clearMemoryPool( );
18532 0 : SgSIMDStore::clearMemoryPool( );
18533 0 : SgSIMDPartialStore::clearMemoryPool( );
18534 0 : SgSIMDScalarStore::clearMemoryPool( );
18535 0 : SgSIMDGather::clearMemoryPool( );
18536 0 : SgSIMDExplicitGather::clearMemoryPool( );
18537 0 : SgSIMDScatter::clearMemoryPool( );
18538 0 : SgSizeOfOp::clearMemoryPool( );
18539 0 : SgAlignOfOp::clearMemoryPool( );
18540 0 : SgSourceFile::clearMemoryPool( );
18541 0 : SgSpaceshipOp::clearMemoryPool( );
18542 0 : SgSpawnStmt::clearMemoryPool( );
18543 0 : SgSyncAllStatement::clearMemoryPool( );
18544 0 : SgSyncImagesStatement::clearMemoryPool( );
18545 0 : SgSyncMemoryStatement::clearMemoryPool( );
18546 0 : SgSyncTeamStatement::clearMemoryPool( );
18547 0 : SgLockStatement::clearMemoryPool( );
18548 0 : SgUnlockStatement::clearMemoryPool( );
18549 0 : SgProcessControlStatement::clearMemoryPool( );
18550 0 : SgSpecialFunctionModifier::clearMemoryPool( );
18551 0 : SgStatement::clearMemoryPool( );
18552 0 : SgStaticAssertionDeclaration::clearMemoryPool( );
18553 0 : SgStmtDeclarationStatement::clearMemoryPool( );
18554 0 : SgStatementExpression::clearMemoryPool( );
18555 0 : SgStatementFunctionStatement::clearMemoryPool( );
18556 0 : SgStorageModifier::clearMemoryPool( );
18557 0 : SgStringConversion::clearMemoryPool( );
18558 0 : SgStringKeyedBidirectionalGraph::clearMemoryPool( );
18559 0 : SgStringVal::clearMemoryPool( );
18560 0 : SgStructureModifier::clearMemoryPool( );
18561 0 : SgSubscriptExpression::clearMemoryPool( );
18562 0 : SgSubtractOp::clearMemoryPool( );
18563 0 : SgSupport::clearMemoryPool( );
18564 0 : SgSwitchStatement::clearMemoryPool( );
18565 0 : SgSymbol::clearMemoryPool( );
18566 0 : SgSymbolTable::clearMemoryPool( );
18567 0 : SgTemplateArgument::clearMemoryPool( );
18568 0 : SgTemplateArgumentList::clearMemoryPool( );
18569 0 : SgTemplateDeclaration::clearMemoryPool( );
18570 0 : SgTemplateClassDeclaration::clearMemoryPool( );
18571 0 : SgTemplateClassSymbol::clearMemoryPool( );
18572 0 : SgTemplateFunctionDeclaration::clearMemoryPool( );
18573 0 : SgTemplateFunctionRefExp::clearMemoryPool( );
18574 0 : SgTemplateFunctionSymbol::clearMemoryPool( );
18575 0 : SgTemplateMemberFunctionDeclaration::clearMemoryPool( );
18576 0 : SgTemplateMemberFunctionRefExp::clearMemoryPool( );
18577 0 : SgTemplateMemberFunctionSymbol::clearMemoryPool( );
18578 0 : SgTemplateTypedefDeclaration::clearMemoryPool( );
18579 0 : SgTemplateTypedefSymbol::clearMemoryPool( );
18580 0 : SgTemplateVariableDeclaration::clearMemoryPool( );
18581 0 : SgTemplateVariableSymbol::clearMemoryPool( );
18582 0 : SgTemplateClassDefinition::clearMemoryPool( );
18583 0 : SgTemplateFunctionDefinition::clearMemoryPool( );
18584 0 : SgTemplateInstantiationDecl::clearMemoryPool( );
18585 0 : SgTemplateInstantiationDefn::clearMemoryPool( );
18586 0 : SgTemplateInstantiationDirectiveStatement::clearMemoryPool( );
18587 0 : SgTemplateInstantiationFunctionDecl::clearMemoryPool( );
18588 0 : SgTemplateInstantiationMemberFunctionDecl::clearMemoryPool( );
18589 0 : SgTemplateInstantiationTypedefDeclaration::clearMemoryPool( );
18590 0 : SgTemplateParameter::clearMemoryPool( );
18591 0 : SgTemplateParameterVal::clearMemoryPool( );
18592 0 : SgTemplateParameterList::clearMemoryPool( );
18593 0 : SgTemplateSymbol::clearMemoryPool( );
18594 0 : SgTemplateType::clearMemoryPool( );
18595 0 : SgThisExp::clearMemoryPool( );
18596 0 : SgTypeTraitBuiltinOperator::clearMemoryPool( );
18597 0 : SgSuperExp::clearMemoryPool( );
18598 0 : SgThrowOp::clearMemoryPool( );
18599 0 : SgToken::clearMemoryPool( );
18600 0 : SgTryStmt::clearMemoryPool( );
18601 0 : SgTupleExp::clearMemoryPool( );
18602 0 : SgType::clearMemoryPool( );
18603 0 : SgTypeBool::clearMemoryPool( );
18604 0 : SgTypeChar::clearMemoryPool( );
18605 0 : SgTypeChar16::clearMemoryPool( );
18606 0 : SgTypeChar32::clearMemoryPool( );
18607 0 : SgTypeComplex::clearMemoryPool( );
18608 0 : SgTypeDefault::clearMemoryPool( );
18609 0 : SgTypeExpression::clearMemoryPool( );
18610 0 : SgTypeLabel::clearMemoryPool( );
18611 0 : SgTypeDouble::clearMemoryPool( );
18612 0 : SgTypeEllipse::clearMemoryPool( );
18613 0 : SgTypeFixed::clearMemoryPool( );
18614 0 : SgTypeFloat::clearMemoryPool( );
18615 0 : SgTypeFloat128::clearMemoryPool( );
18616 0 : SgTypeFloat80::clearMemoryPool( );
18617 0 : SgTypeGlobalVoid::clearMemoryPool( );
18618 0 : SgTypeIdOp::clearMemoryPool( );
18619 0 : SgTypeImaginary::clearMemoryPool( );
18620 0 : SgTypeInt::clearMemoryPool( );
18621 0 : SgTypeLong::clearMemoryPool( );
18622 0 : SgTypeLongDouble::clearMemoryPool( );
18623 0 : SgTypeLongLong::clearMemoryPool( );
18624 0 : SgTypeModifier::clearMemoryPool( );
18625 0 : SgTypeMatrix::clearMemoryPool( );
18626 0 : SgTypeTuple::clearMemoryPool( );
18627 0 : SgTypeNullptr::clearMemoryPool( );
18628 0 : SgTypeOfType::clearMemoryPool( );
18629 0 : SgTypeShort::clearMemoryPool( );
18630 0 : SgTypeSigned128bitInteger::clearMemoryPool( );
18631 0 : SgTypeSignedChar::clearMemoryPool( );
18632 0 : SgTypeSignedInt::clearMemoryPool( );
18633 0 : SgTypeSignedLong::clearMemoryPool( );
18634 0 : SgTypeSignedLongLong::clearMemoryPool( );
18635 0 : SgTypeSignedShort::clearMemoryPool( );
18636 0 : SgTypeString::clearMemoryPool( );
18637 0 : SgTypeUnknown::clearMemoryPool( );
18638 0 : SgTypeUnsigned128bitInteger::clearMemoryPool( );
18639 0 : SgTypeUnsignedChar::clearMemoryPool( );
18640 0 : SgTypeUnsignedInt::clearMemoryPool( );
18641 0 : SgTypeUnsignedLong::clearMemoryPool( );
18642 0 : SgTypeUnsignedLongLong::clearMemoryPool( );
18643 0 : SgTypeUnsignedShort::clearMemoryPool( );
18644 0 : SgTypeVoid::clearMemoryPool( );
18645 0 : SgTypeWchar::clearMemoryPool( );
18646 0 : SgTypedefDeclaration::clearMemoryPool( );
18647 0 : SgTypedefSeq::clearMemoryPool( );
18648 0 : SgTypedefSymbol::clearMemoryPool( );
18649 0 : SgTypedefType::clearMemoryPool( );
18650 0 : SgUPC_AccessModifier::clearMemoryPool( );
18651 0 : SgUnaryAddOp::clearMemoryPool( );
18652 0 : SgUnaryOp::clearMemoryPool( );
18653 0 : SgUndefDirectiveStatement::clearMemoryPool( );
18654 0 : SgUndirectedGraphEdge::clearMemoryPool( );
18655 0 : SgUnknownArrayOrFunctionReference::clearMemoryPool( );
18656 0 : SgUnknownFile::clearMemoryPool( );
18657 0 : SgUnparse_Info::clearMemoryPool( );
18658 0 : SgUnsignedCharVal::clearMemoryPool( );
18659 0 : SgUnsignedIntVal::clearMemoryPool( );
18660 0 : SgUnsignedLongLongIntVal::clearMemoryPool( );
18661 0 : SgUnsignedLongVal::clearMemoryPool( );
18662 0 : SgUnsignedShortVal::clearMemoryPool( );
18663 0 : SgUpcBarrierStatement::clearMemoryPool( );
18664 0 : SgUpcBlocksizeofExpression::clearMemoryPool( );
18665 0 : SgUpcElemsizeofExpression::clearMemoryPool( );
18666 0 : SgUpcFenceStatement::clearMemoryPool( );
18667 0 : SgUpcForAllStatement::clearMemoryPool( );
18668 0 : SgUpcLocalsizeofExpression::clearMemoryPool( );
18669 0 : SgUpcMythread::clearMemoryPool( );
18670 0 : SgUpcNotifyStatement::clearMemoryPool( );
18671 0 : SgUpcThreads::clearMemoryPool( );
18672 0 : SgUpcWaitStatement::clearMemoryPool( );
18673 0 : SgUseStatement::clearMemoryPool( );
18674 0 : SgUserDefinedBinaryOp::clearMemoryPool( );
18675 0 : SgUserDefinedUnaryOp::clearMemoryPool( );
18676 0 : SgUsingDeclarationStatement::clearMemoryPool( );
18677 0 : SgUsingDirectiveStatement::clearMemoryPool( );
18678 0 : SgValueExp::clearMemoryPool( );
18679 0 : SgVarArgCopyOp::clearMemoryPool( );
18680 0 : SgVarArgEndOp::clearMemoryPool( );
18681 0 : SgVarArgOp::clearMemoryPool( );
18682 0 : SgVarArgStartOneOperandOp::clearMemoryPool( );
18683 0 : SgVarArgStartOp::clearMemoryPool( );
18684 0 : SgVarRefExp::clearMemoryPool( );
18685 0 : SgVariableDeclaration::clearMemoryPool( );
18686 0 : SgVariableDefinition::clearMemoryPool( );
18687 0 : SgVariableSymbol::clearMemoryPool( );
18688 0 : SgVariantExpression::clearMemoryPool( );
18689 0 : SgVariantStatement::clearMemoryPool( );
18690 0 : SgVoidVal::clearMemoryPool( );
18691 0 : SgWaitStatement::clearMemoryPool( );
18692 0 : SgWarningDirectiveStatement::clearMemoryPool( );
18693 0 : SgWithStatement::clearMemoryPool( );
18694 0 : SgWcharVal::clearMemoryPool( );
18695 0 : SgWhereStatement::clearMemoryPool( );
18696 0 : SgWhileStmt::clearMemoryPool( );
18697 0 : SgWriteStatement::clearMemoryPool( );
18698 0 : SgXorAssignOp::clearMemoryPool( );
18699 0 : SgYieldExpression::clearMemoryPool( );
18700 0 : Sg_File_Info::clearMemoryPool( );
18701 0 : SgTypeCAFTeam::clearMemoryPool( );
18702 0 : SgCAFWithTeamStatement::clearMemoryPool( );
18703 0 : SgCAFCoExpression::clearMemoryPool( );
18704 0 : SgCallExpression::clearMemoryPool( );
18705 0 : SgTypeCrayPointer::clearMemoryPool( );
18706 0 : SgClassExp::clearMemoryPool( );
18707 :
18708 : /* #line 353 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
18709 :
18710 :
18711 : /* JH (02/03/2006) since the memory pool contain no data anymore, we reset the
18712 : contents of the listOfMemoryPoolSizes to 0!
18713 : */
18714 0 : for (int i= 0; i < totalNumberOfIRNodes + 1; ++i)
18715 : {
18716 0 : listOfMemoryPoolSizes[i] = 0;
18717 : }
18718 : /* JH (03/21/2006) additionally, we need a method, that resets the static
18719 : data pointers to NULL!
18720 : */
18721 0 : deleteStaticData();
18722 0 : deleteStoredAsts();
18723 0 : return;
18724 : }
18725 :
18726 5 : void AST_FILE_IO::deleteMemoryPools( ) {
18727 :
18728 5 : SgAccessModifier::deleteMemoryPool( );
18729 5 : SgActualArgumentExpression::deleteMemoryPool( );
18730 5 : SgAddOp::deleteMemoryPool( );
18731 5 : SgAddressOfOp::deleteMemoryPool( );
18732 5 : SgAggregateInitializer::deleteMemoryPool( );
18733 5 : SgAliasSymbol::deleteMemoryPool( );
18734 5 : SgAllocateStatement::deleteMemoryPool( );
18735 5 : SgAndAssignOp::deleteMemoryPool( );
18736 5 : SgAndOp::deleteMemoryPool( );
18737 5 : SgArithmeticIfStatement::deleteMemoryPool( );
18738 5 : SgArrayType::deleteMemoryPool( );
18739 5 : SgArrowExp::deleteMemoryPool( );
18740 5 : SgArrowStarOp::deleteMemoryPool( );
18741 5 : SgAsmOp::deleteMemoryPool( );
18742 5 : SgAsmStmt::deleteMemoryPool( );
18743 5 : SgAssertStmt::deleteMemoryPool( );
18744 5 : SgAssignInitializer::deleteMemoryPool( );
18745 5 : SgAssignOp::deleteMemoryPool( );
18746 5 : SgAssignStatement::deleteMemoryPool( );
18747 5 : SgAssignedGotoStatement::deleteMemoryPool( );
18748 5 : SgAssociateStatement::deleteMemoryPool( );
18749 5 : SgAsteriskShapeExp::deleteMemoryPool( );
18750 5 : SgAttribute::deleteMemoryPool( );
18751 5 : SgAttributeSpecificationStatement::deleteMemoryPool( );
18752 5 : SgAutoType::deleteMemoryPool( );
18753 5 : SgAwaitExpression::deleteMemoryPool( );
18754 5 : SgBackspaceStatement::deleteMemoryPool( );
18755 5 : SgBaseClass::deleteMemoryPool( );
18756 5 : SgExpBaseClass::deleteMemoryPool( );
18757 5 : SgBaseClassModifier::deleteMemoryPool( );
18758 5 : SgBasicBlock::deleteMemoryPool( );
18759 5 : SgBidirectionalGraph::deleteMemoryPool( );
18760 5 : SgBinaryOp::deleteMemoryPool( );
18761 5 : SgBitAndOp::deleteMemoryPool( );
18762 5 : SgBitAttribute::deleteMemoryPool( );
18763 5 : SgBitComplementOp::deleteMemoryPool( );
18764 5 : SgBitEqvOp::deleteMemoryPool( );
18765 5 : SgBitOrOp::deleteMemoryPool( );
18766 5 : SgBitXorOp::deleteMemoryPool( );
18767 5 : SgBlockDataStatement::deleteMemoryPool( );
18768 5 : SgBoolValExp::deleteMemoryPool( );
18769 5 : SgBreakStmt::deleteMemoryPool( );
18770 5 : SgBracedInitializer::deleteMemoryPool( );
18771 5 : SgC_PreprocessorDirectiveStatement::deleteMemoryPool( );
18772 5 : SgCaseOptionStmt::deleteMemoryPool( );
18773 5 : SgCastExp::deleteMemoryPool( );
18774 5 : SgCatchOptionStmt::deleteMemoryPool( );
18775 5 : SgCatchStatementSeq::deleteMemoryPool( );
18776 5 : SgCharVal::deleteMemoryPool( );
18777 5 : SgChar16Val::deleteMemoryPool( );
18778 5 : SgChar32Val::deleteMemoryPool( );
18779 5 : SgChooseExpression::deleteMemoryPool( );
18780 5 : SgClassDecl_attr::deleteMemoryPool( );
18781 5 : SgClassDeclaration::deleteMemoryPool( );
18782 5 : SgClassDefinition::deleteMemoryPool( );
18783 5 : SgClassNameRefExp::deleteMemoryPool( );
18784 5 : SgClassSymbol::deleteMemoryPool( );
18785 5 : SgClassType::deleteMemoryPool( );
18786 5 : SgClinkageDeclarationStatement::deleteMemoryPool( );
18787 5 : SgClinkageEndStatement::deleteMemoryPool( );
18788 5 : SgClinkageStartStatement::deleteMemoryPool( );
18789 5 : SgCloseStatement::deleteMemoryPool( );
18790 5 : SgColonShapeExp::deleteMemoryPool( );
18791 5 : SgCommaOpExp::deleteMemoryPool( );
18792 5 : SgCommonBlock::deleteMemoryPool( );
18793 5 : SgCommonBlockObject::deleteMemoryPool( );
18794 5 : SgCommonSymbol::deleteMemoryPool( );
18795 5 : SgComplexVal::deleteMemoryPool( );
18796 5 : SgComprehension::deleteMemoryPool( );
18797 5 : SgCompoundAssignOp::deleteMemoryPool( );
18798 5 : SgCompoundInitializer::deleteMemoryPool( );
18799 5 : SgCompoundLiteralExp::deleteMemoryPool( );
18800 5 : SgComputedGotoStatement::deleteMemoryPool( );
18801 5 : SgConcatenationOp::deleteMemoryPool( );
18802 5 : SgConditionalExp::deleteMemoryPool( );
18803 5 : SgConjugateOp::deleteMemoryPool( );
18804 5 : SgConstVolatileModifier::deleteMemoryPool( );
18805 5 : SgConstructorInitializer::deleteMemoryPool( );
18806 5 : SgContainsStatement::deleteMemoryPool( );
18807 5 : SgContinueStmt::deleteMemoryPool( );
18808 5 : SgCtorInitializerList::deleteMemoryPool( );
18809 5 : SgDataStatementGroup::deleteMemoryPool( );
18810 5 : SgDataStatementObject::deleteMemoryPool( );
18811 5 : SgDataStatementValue::deleteMemoryPool( );
18812 5 : SgDeadIfDirectiveStatement::deleteMemoryPool( );
18813 5 : SgDeallocateStatement::deleteMemoryPool( );
18814 5 : SgDeclarationModifier::deleteMemoryPool( );
18815 5 : SgDeclarationScope::deleteMemoryPool( );
18816 5 : SgDeclarationStatement::deleteMemoryPool( );
18817 5 : SgDeclType::deleteMemoryPool( );
18818 5 : SgDefaultOptionStmt::deleteMemoryPool( );
18819 5 : SgDefaultSymbol::deleteMemoryPool( );
18820 5 : SgDefineDirectiveStatement::deleteMemoryPool( );
18821 5 : SgDeleteExp::deleteMemoryPool( );
18822 5 : SgDerivedTypeStatement::deleteMemoryPool( );
18823 5 : SgDesignatedInitializer::deleteMemoryPool( );
18824 5 : SgDictionaryComprehension::deleteMemoryPool( );
18825 5 : SgDictionaryExp::deleteMemoryPool( );
18826 5 : SgDimensionObject::deleteMemoryPool( );
18827 5 : SgDirectedGraphEdge::deleteMemoryPool( );
18828 5 : SgDirectory::deleteMemoryPool( );
18829 5 : SgDirectoryList::deleteMemoryPool( );
18830 5 : SgDivAssignOp::deleteMemoryPool( );
18831 5 : SgDivideOp::deleteMemoryPool( );
18832 5 : SgDoWhileStmt::deleteMemoryPool( );
18833 5 : SgDotExp::deleteMemoryPool( );
18834 5 : SgDotStarOp::deleteMemoryPool( );
18835 5 : SgDoubleVal::deleteMemoryPool( );
18836 5 : SgElaboratedTypeModifier::deleteMemoryPool( );
18837 5 : SgElementwiseOp::deleteMemoryPool( );
18838 5 : SgElementwiseAddOp::deleteMemoryPool( );
18839 5 : SgElementwiseDivideOp::deleteMemoryPool( );
18840 5 : SgElementwiseLeftDivideOp::deleteMemoryPool( );
18841 5 : SgElementwiseMultiplyOp::deleteMemoryPool( );
18842 5 : SgElementwisePowerOp::deleteMemoryPool( );
18843 5 : SgElementwiseSubtractOp::deleteMemoryPool( );
18844 5 : SgElseDirectiveStatement::deleteMemoryPool( );
18845 5 : SgElseWhereStatement::deleteMemoryPool( );
18846 5 : SgElseifDirectiveStatement::deleteMemoryPool( );
18847 5 : SgEmptyDeclaration::deleteMemoryPool( );
18848 5 : SgEmptyDirectiveStatement::deleteMemoryPool( );
18849 5 : SgEndfileStatement::deleteMemoryPool( );
18850 5 : SgEndifDirectiveStatement::deleteMemoryPool( );
18851 5 : SgEntryStatement::deleteMemoryPool( );
18852 5 : SgEnumDeclaration::deleteMemoryPool( );
18853 5 : SgEnumFieldSymbol::deleteMemoryPool( );
18854 5 : SgEnumSymbol::deleteMemoryPool( );
18855 5 : SgEnumType::deleteMemoryPool( );
18856 5 : SgEnumVal::deleteMemoryPool( );
18857 5 : SgEqualityOp::deleteMemoryPool( );
18858 5 : SgEquivalenceStatement::deleteMemoryPool( );
18859 5 : SgErrorDirectiveStatement::deleteMemoryPool( );
18860 5 : SgExecStatement::deleteMemoryPool( );
18861 5 : SgExponentiationOp::deleteMemoryPool( );
18862 5 : SgExponentiationAssignOp::deleteMemoryPool( );
18863 5 : SgExprListExp::deleteMemoryPool( );
18864 5 : SgExprStatement::deleteMemoryPool( );
18865 5 : SgExpression::deleteMemoryPool( );
18866 5 : SgExpressionRoot::deleteMemoryPool( );
18867 5 : SgFile::deleteMemoryPool( );
18868 5 : SgFileList::deleteMemoryPool( );
18869 5 : SgFloatVal::deleteMemoryPool( );
18870 5 : SgFloat128Val::deleteMemoryPool( );
18871 5 : SgFloat80Val::deleteMemoryPool( );
18872 5 : SgFoldExpression::deleteMemoryPool( );
18873 5 : SgFlushStatement::deleteMemoryPool( );
18874 5 : SgForAllStatement::deleteMemoryPool( );
18875 5 : SgForInitStatement::deleteMemoryPool( );
18876 5 : SgForStatement::deleteMemoryPool( );
18877 5 : SgFormatItem::deleteMemoryPool( );
18878 5 : SgFormatItemList::deleteMemoryPool( );
18879 5 : SgFormatStatement::deleteMemoryPool( );
18880 5 : SgFortranDo::deleteMemoryPool( );
18881 5 : SgFortranIncludeLine::deleteMemoryPool( );
18882 5 : SgFortranNonblockedDo::deleteMemoryPool( );
18883 5 : SgFuncDecl_attr::deleteMemoryPool( );
18884 5 : SgFunctionCallExp::deleteMemoryPool( );
18885 5 : SgFunctionDeclaration::deleteMemoryPool( );
18886 5 : SgFunctionDefinition::deleteMemoryPool( );
18887 5 : SgFunctionParameterScope::deleteMemoryPool( );
18888 5 : SgFunctionModifier::deleteMemoryPool( );
18889 5 : SgFunctionParameterList::deleteMemoryPool( );
18890 5 : SgFunctionParameterRefExp::deleteMemoryPool( );
18891 5 : SgFunctionParameterTypeList::deleteMemoryPool( );
18892 5 : SgFunctionRefExp::deleteMemoryPool( );
18893 5 : SgFunctionSymbol::deleteMemoryPool( );
18894 5 : SgFunctionType::deleteMemoryPool( );
18895 5 : SgFunctionTypeSymbol::deleteMemoryPool( );
18896 5 : SgFunctionTypeTable::deleteMemoryPool( );
18897 5 : SgTypeTable::deleteMemoryPool( );
18898 5 : SgGlobal::deleteMemoryPool( );
18899 5 : SgGotoStatement::deleteMemoryPool( );
18900 5 : SgGraph::deleteMemoryPool( );
18901 5 : SgGraphEdge::deleteMemoryPool( );
18902 5 : SgGraphEdgeList::deleteMemoryPool( );
18903 5 : SgGraphNode::deleteMemoryPool( );
18904 5 : SgGraphNodeList::deleteMemoryPool( );
18905 5 : SgGreaterOrEqualOp::deleteMemoryPool( );
18906 5 : SgGreaterThanOp::deleteMemoryPool( );
18907 5 : SgIOItemExpression::deleteMemoryPool( );
18908 5 : SgIOStatement::deleteMemoryPool( );
18909 5 : SgIdentDirectiveStatement::deleteMemoryPool( );
18910 5 : SgIfDirectiveStatement::deleteMemoryPool( );
18911 5 : SgIfStmt::deleteMemoryPool( );
18912 5 : SgIfdefDirectiveStatement::deleteMemoryPool( );
18913 5 : SgIfndefDirectiveStatement::deleteMemoryPool( );
18914 5 : SgImageControlStatement::deleteMemoryPool( );
18915 5 : SgImagPartOp::deleteMemoryPool( );
18916 5 : SgImplicitStatement::deleteMemoryPool( );
18917 5 : SgImpliedDo::deleteMemoryPool( );
18918 5 : SgImportStatement::deleteMemoryPool( );
18919 5 : SgIncidenceDirectedGraph::deleteMemoryPool( );
18920 5 : SgIncidenceUndirectedGraph::deleteMemoryPool( );
18921 5 : SgIncludeDirectiveStatement::deleteMemoryPool( );
18922 5 : SgIncludeFile::deleteMemoryPool( );
18923 5 : SgIncludeNextDirectiveStatement::deleteMemoryPool( );
18924 5 : SgInitializedName::deleteMemoryPool( );
18925 5 : SgInitializer::deleteMemoryPool( );
18926 5 : SgInquireStatement::deleteMemoryPool( );
18927 5 : SgIntKeyedBidirectionalGraph::deleteMemoryPool( );
18928 5 : SgIntVal::deleteMemoryPool( );
18929 5 : SgIntegerDivideOp::deleteMemoryPool( );
18930 5 : SgIntegerDivideAssignOp::deleteMemoryPool( );
18931 5 : SgInterfaceBody::deleteMemoryPool( );
18932 5 : SgHeaderFileBody::deleteMemoryPool( );
18933 5 : SgHeaderFileReport::deleteMemoryPool( );
18934 5 : SgInterfaceStatement::deleteMemoryPool( );
18935 5 : SgInterfaceSymbol::deleteMemoryPool( );
18936 5 : SgIntrinsicSymbol::deleteMemoryPool( );
18937 5 : SgIsOp::deleteMemoryPool( );
18938 5 : SgIsNotOp::deleteMemoryPool( );
18939 5 : SgIorAssignOp::deleteMemoryPool( );
18940 5 : SgKeyDatumPair::deleteMemoryPool( );
18941 5 : SgCudaKernelExecConfig::deleteMemoryPool( );
18942 5 : SgCudaKernelCallExp::deleteMemoryPool( );
18943 5 : SgLabelRefExp::deleteMemoryPool( );
18944 5 : SgLabelStatement::deleteMemoryPool( );
18945 5 : SgLabelSymbol::deleteMemoryPool( );
18946 5 : SgLambdaCapture::deleteMemoryPool( );
18947 5 : SgLambdaCaptureList::deleteMemoryPool( );
18948 5 : SgLambdaExp::deleteMemoryPool( );
18949 5 : SgLambdaRefExp::deleteMemoryPool( );
18950 5 : SgLeftDivideOp::deleteMemoryPool( );
18951 5 : SgLessOrEqualOp::deleteMemoryPool( );
18952 5 : SgLessThanOp::deleteMemoryPool( );
18953 5 : SgLineDirectiveStatement::deleteMemoryPool( );
18954 5 : SgLinemarkerDirectiveStatement::deleteMemoryPool( );
18955 5 : SgLinkageModifier::deleteMemoryPool( );
18956 5 : SgListComprehension::deleteMemoryPool( );
18957 5 : SgListExp::deleteMemoryPool( );
18958 5 : SgLocatedNode::deleteMemoryPool( );
18959 5 : SgLocatedNodeSupport::deleteMemoryPool( );
18960 5 : SgLongDoubleVal::deleteMemoryPool( );
18961 5 : SgLongIntVal::deleteMemoryPool( );
18962 5 : SgLongLongIntVal::deleteMemoryPool( );
18963 5 : SgLshiftAssignOp::deleteMemoryPool( );
18964 5 : SgLshiftOp::deleteMemoryPool( );
18965 5 : SgMagicColonExp::deleteMemoryPool( );
18966 5 : SgMatrixExp::deleteMemoryPool( );
18967 5 : SgMatrixTransposeOp::deleteMemoryPool( );
18968 5 : SgMemberFunctionDeclaration::deleteMemoryPool( );
18969 5 : SgMemberFunctionRefExp::deleteMemoryPool( );
18970 5 : SgMemberFunctionSymbol::deleteMemoryPool( );
18971 5 : SgMemberFunctionType::deleteMemoryPool( );
18972 5 : SgMembershipOp::deleteMemoryPool( );
18973 5 : SgMicrosoftAttributeDeclaration::deleteMemoryPool( );
18974 5 : SgMinusAssignOp::deleteMemoryPool( );
18975 5 : SgMinusMinusOp::deleteMemoryPool( );
18976 5 : SgMinusOp::deleteMemoryPool( );
18977 5 : SgModAssignOp::deleteMemoryPool( );
18978 5 : SgModOp::deleteMemoryPool( );
18979 5 : SgModifier::deleteMemoryPool( );
18980 5 : SgModifierNodes::deleteMemoryPool( );
18981 5 : SgModifierType::deleteMemoryPool( );
18982 5 : SgModuleStatement::deleteMemoryPool( );
18983 5 : SgModuleSymbol::deleteMemoryPool( );
18984 5 : SgMultAssignOp::deleteMemoryPool( );
18985 5 : SgMultiplyOp::deleteMemoryPool( );
18986 5 : SgName::deleteMemoryPool( );
18987 5 : SgNameGroup::deleteMemoryPool( );
18988 5 : SgNamedType::deleteMemoryPool( );
18989 5 : SgNamelistStatement::deleteMemoryPool( );
18990 5 : SgNamespaceAliasDeclarationStatement::deleteMemoryPool( );
18991 5 : SgNamespaceDeclarationStatement::deleteMemoryPool( );
18992 5 : SgNamespaceDefinitionStatement::deleteMemoryPool( );
18993 5 : SgNamespaceSymbol::deleteMemoryPool( );
18994 5 : SgNaryOp::deleteMemoryPool( );
18995 5 : SgNaryBooleanOp::deleteMemoryPool( );
18996 5 : SgNaryComparisonOp::deleteMemoryPool( );
18997 5 : SgNewExp::deleteMemoryPool( );
18998 5 : SgNode::deleteMemoryPool( );
18999 5 : SgNoexceptOp::deleteMemoryPool( );
19000 5 : SgNotEqualOp::deleteMemoryPool( );
19001 5 : SgNotOp::deleteMemoryPool( );
19002 5 : SgNonMembershipOp::deleteMemoryPool( );
19003 5 : SgNonrealDecl::deleteMemoryPool( );
19004 5 : SgNonrealRefExp::deleteMemoryPool( );
19005 5 : SgNonrealSymbol::deleteMemoryPool( );
19006 5 : SgNonrealType::deleteMemoryPool( );
19007 5 : SgNonrealBaseClass::deleteMemoryPool( );
19008 5 : SgNullExpression::deleteMemoryPool( );
19009 5 : SgNullptrValExp::deleteMemoryPool( );
19010 5 : SgNullStatement::deleteMemoryPool( );
19011 5 : SgNullifyStatement::deleteMemoryPool( );
19012 5 : SgOmpAtomicStatement::deleteMemoryPool( );
19013 5 : SgOmpBarrierStatement::deleteMemoryPool( );
19014 5 : SgOmpCriticalStatement::deleteMemoryPool( );
19015 5 : SgUpirFieldBodyStatement::deleteMemoryPool( );
19016 5 : SgUpirBodyStatement::deleteMemoryPool( );
19017 5 : SgUpirFieldStatement::deleteMemoryPool( );
19018 5 : SgOmpDoStatement::deleteMemoryPool( );
19019 5 : SgOmpFlushStatement::deleteMemoryPool( );
19020 5 : SgOmpAllocateStatement::deleteMemoryPool( );
19021 5 : SgOmpDeclareSimdStatement::deleteMemoryPool( );
19022 5 : SgUpirWorksharingStatement::deleteMemoryPool( );
19023 5 : SgOmpForSimdStatement::deleteMemoryPool( );
19024 5 : SgOmpMasterStatement::deleteMemoryPool( );
19025 5 : SgOmpTaskyieldStatement::deleteMemoryPool( );
19026 5 : SgOmpMetadirectiveStatement::deleteMemoryPool( );
19027 5 : SgOmpOrderedStatement::deleteMemoryPool( );
19028 5 : SgOmpOrderedDependStatement::deleteMemoryPool( );
19029 5 : SgUpirSpmdStatement::deleteMemoryPool( );
19030 5 : SgOmpTeamsStatement::deleteMemoryPool( );
19031 5 : SgOmpCancellationPointStatement::deleteMemoryPool( );
19032 5 : SgOmpDeclareMapperStatement::deleteMemoryPool( );
19033 5 : SgOmpCancelStatement::deleteMemoryPool( );
19034 5 : SgOmpTaskgroupStatement::deleteMemoryPool( );
19035 5 : SgOmpDepobjStatement::deleteMemoryPool( );
19036 5 : SgOmpDistributeStatement::deleteMemoryPool( );
19037 5 : SgOmpLoopStatement::deleteMemoryPool( );
19038 5 : SgOmpScanStatement::deleteMemoryPool( );
19039 5 : SgOmpTaskloopStatement::deleteMemoryPool( );
19040 5 : SgOmpTargetEnterDataStatement::deleteMemoryPool( );
19041 5 : SgOmpTargetExitDataStatement::deleteMemoryPool( );
19042 5 : SgOmpSectionStatement::deleteMemoryPool( );
19043 5 : SgOmpSectionsStatement::deleteMemoryPool( );
19044 5 : SgOmpSingleStatement::deleteMemoryPool( );
19045 5 : SgOmpTaskStatement::deleteMemoryPool( );
19046 5 : SgOmpTaskwaitStatement::deleteMemoryPool( );
19047 5 : SgOmpThreadprivateStatement::deleteMemoryPool( );
19048 5 : SgOmpWorkshareStatement::deleteMemoryPool( );
19049 5 : SgUpirTaskStatement::deleteMemoryPool( );
19050 5 : SgOmpTargetDataStatement::deleteMemoryPool( );
19051 5 : SgOmpTargetParallelForStatement::deleteMemoryPool( );
19052 5 : SgOmpTargetUpdateStatement::deleteMemoryPool( );
19053 5 : SgOmpRequiresStatement::deleteMemoryPool( );
19054 5 : SgOmpTargetParallelStatement::deleteMemoryPool( );
19055 5 : SgOmpTargetParallelForSimdStatement::deleteMemoryPool( );
19056 5 : SgOmpTargetParallelLoopStatement::deleteMemoryPool( );
19057 5 : SgOmpTargetSimdStatement::deleteMemoryPool( );
19058 5 : SgOmpTargetTeamsStatement::deleteMemoryPool( );
19059 5 : SgOmpTargetTeamsDistributeStatement::deleteMemoryPool( );
19060 5 : SgOmpTargetTeamsDistributeSimdStatement::deleteMemoryPool( );
19061 5 : SgOmpTargetTeamsLoopStatement::deleteMemoryPool( );
19062 5 : SgOmpTargetTeamsDistributeParallelForStatement::deleteMemoryPool( );
19063 5 : SgOmpTargetTeamsDistributeParallelForSimdStatement::deleteMemoryPool( );
19064 5 : SgOmpDistributeSimdStatement::deleteMemoryPool( );
19065 5 : SgOmpDistributeParallelForStatement::deleteMemoryPool( );
19066 5 : SgOmpDistributeParallelForSimdStatement::deleteMemoryPool( );
19067 5 : SgOmpTaskloopSimdStatement::deleteMemoryPool( );
19068 5 : SgOmpMasterTaskloopSimdStatement::deleteMemoryPool( );
19069 5 : SgOmpParallelMasterTaskloopStatement::deleteMemoryPool( );
19070 5 : SgOmpParallelMasterTaskloopSimdStatement::deleteMemoryPool( );
19071 5 : SgOmpTeamsDistributeStatement::deleteMemoryPool( );
19072 5 : SgOmpTeamsDistributeSimdStatement::deleteMemoryPool( );
19073 5 : SgOmpTeamsDistributeParallelForStatement::deleteMemoryPool( );
19074 5 : SgOmpTeamsDistributeParallelForSimdStatement::deleteMemoryPool( );
19075 5 : SgOmpTeamsLoopStatement::deleteMemoryPool( );
19076 5 : SgOmpParallelLoopStatement::deleteMemoryPool( );
19077 5 : SgOmpParallelMasterStatement::deleteMemoryPool( );
19078 5 : SgOmpMasterTaskloopStatement::deleteMemoryPool( );
19079 5 : SgOmpUnrollStatement::deleteMemoryPool( );
19080 5 : SgOmpTileStatement::deleteMemoryPool( );
19081 5 : SgUpirSimdStatement::deleteMemoryPool( );
19082 5 : SgUpirBaseStatement::deleteMemoryPool( );
19083 5 : SgUpirLoopStatement::deleteMemoryPool( );
19084 5 : SgUpirLoopParallelStatement::deleteMemoryPool( );
19085 5 : SgUpirSyncStatement::deleteMemoryPool( );
19086 5 : SgOmpClause::deleteMemoryPool( );
19087 5 : SgOmpAllocateClause::deleteMemoryPool( );
19088 5 : SgOmpAllocatorClause::deleteMemoryPool( );
19089 5 : SgOmpUsesAllocatorsClause::deleteMemoryPool( );
19090 5 : SgOmpUsesAllocatorsDefination::deleteMemoryPool( );
19091 5 : SgOmpToClause::deleteMemoryPool( );
19092 5 : SgOmpFromClause::deleteMemoryPool( );
19093 5 : SgOmpThreadsClause::deleteMemoryPool( );
19094 5 : SgOmpSimdClause::deleteMemoryPool( );
19095 5 : SgOmpBeginClause::deleteMemoryPool( );
19096 5 : SgOmpCollapseClause::deleteMemoryPool( );
19097 5 : SgOmpCopyinClause::deleteMemoryPool( );
19098 5 : SgOmpCopyprivateClause::deleteMemoryPool( );
19099 5 : SgOmpDefaultClause::deleteMemoryPool( );
19100 5 : SgOmpEndClause::deleteMemoryPool( );
19101 5 : SgOmpExpressionClause::deleteMemoryPool( );
19102 5 : SgOmpFirstprivateClause::deleteMemoryPool( );
19103 5 : SgOmpIfClause::deleteMemoryPool( );
19104 5 : SgOmpFinalClause::deleteMemoryPool( );
19105 5 : SgOmpPriorityClause::deleteMemoryPool( );
19106 5 : SgOmpDeviceClause::deleteMemoryPool( );
19107 5 : SgOmpLastprivateClause::deleteMemoryPool( );
19108 5 : SgOmpNowaitClause::deleteMemoryPool( );
19109 5 : SgOmpReadClause::deleteMemoryPool( );
19110 5 : SgOmpWriteClause::deleteMemoryPool( );
19111 5 : SgOmpUpdateClause::deleteMemoryPool( );
19112 5 : SgOmpDepobjUpdateClause::deleteMemoryPool( );
19113 5 : SgOmpDestroyClause::deleteMemoryPool( );
19114 5 : SgOmpCaptureClause::deleteMemoryPool( );
19115 5 : SgOmpSeqCstClause::deleteMemoryPool( );
19116 5 : SgOmpAcqRelClause::deleteMemoryPool( );
19117 5 : SgOmpReleaseClause::deleteMemoryPool( );
19118 5 : SgOmpAcquireClause::deleteMemoryPool( );
19119 5 : SgOmpReverseOffloadClause::deleteMemoryPool( );
19120 5 : SgOmpUnifiedAddressClause::deleteMemoryPool( );
19121 5 : SgOmpUnifiedSharedMemoryClause::deleteMemoryPool( );
19122 5 : SgOmpDynamicAllocatorsClause::deleteMemoryPool( );
19123 5 : SgOmpAtomicDefaultMemOrderClause::deleteMemoryPool( );
19124 5 : SgOmpExtImplementationDefinedRequirementClause::deleteMemoryPool( );
19125 5 : SgOmpRelaxedClause::deleteMemoryPool( );
19126 5 : SgOmpParallelClause::deleteMemoryPool( );
19127 5 : SgOmpSectionsClause::deleteMemoryPool( );
19128 5 : SgOmpForClause::deleteMemoryPool( );
19129 5 : SgOmpTaskgroupClause::deleteMemoryPool( );
19130 5 : SgUpirNumUnitsField::deleteMemoryPool( );
19131 5 : SgOmpNumTeamsClause::deleteMemoryPool( );
19132 5 : SgOmpGrainsizeClause::deleteMemoryPool( );
19133 5 : SgOmpDetachClause::deleteMemoryPool( );
19134 5 : SgOmpNumTasksClause::deleteMemoryPool( );
19135 5 : SgOmpNogroupClause::deleteMemoryPool( );
19136 5 : SgOmpHintClause::deleteMemoryPool( );
19137 5 : SgOmpOrderClause::deleteMemoryPool( );
19138 5 : SgOmpDistScheduleClause::deleteMemoryPool( );
19139 5 : SgOmpBindClause::deleteMemoryPool( );
19140 5 : SgOmpNontemporalClause::deleteMemoryPool( );
19141 5 : SgOmpInclusiveClause::deleteMemoryPool( );
19142 5 : SgOmpExclusiveClause::deleteMemoryPool( );
19143 5 : SgOmpIsDevicePtrClause::deleteMemoryPool( );
19144 5 : SgOmpUseDevicePtrClause::deleteMemoryPool( );
19145 5 : SgOmpUseDeviceAddrClause::deleteMemoryPool( );
19146 5 : SgOmpThreadLimitClause::deleteMemoryPool( );
19147 5 : SgOmpOrderedClause::deleteMemoryPool( );
19148 5 : SgOmpPrivateClause::deleteMemoryPool( );
19149 5 : SgOmpReductionClause::deleteMemoryPool( );
19150 5 : SgOmpInReductionClause::deleteMemoryPool( );
19151 5 : SgOmpTaskReductionClause::deleteMemoryPool( );
19152 5 : SgOmpDefaultmapClause::deleteMemoryPool( );
19153 5 : SgOmpScheduleClause::deleteMemoryPool( );
19154 5 : SgOmpSharedClause::deleteMemoryPool( );
19155 5 : SgOmpUntiedClause::deleteMemoryPool( );
19156 5 : SgOmpMergeableClause::deleteMemoryPool( );
19157 5 : SgOmpVariablesClause::deleteMemoryPool( );
19158 5 : SgOmpMapClause::deleteMemoryPool( );
19159 5 : SgOmpSafelenClause::deleteMemoryPool( );
19160 5 : SgOmpSimdlenClause::deleteMemoryPool( );
19161 5 : SgOmpLinearClause::deleteMemoryPool( );
19162 5 : SgOmpUniformClause::deleteMemoryPool( );
19163 5 : SgOmpAlignedClause::deleteMemoryPool( );
19164 5 : SgOmpProcBindClause::deleteMemoryPool( );
19165 5 : SgOmpAtomicClause::deleteMemoryPool( );
19166 5 : SgOmpInbranchClause::deleteMemoryPool( );
19167 5 : SgOmpNotinbranchClause::deleteMemoryPool( );
19168 5 : SgOmpDependClause::deleteMemoryPool( );
19169 5 : SgOmpAffinityClause::deleteMemoryPool( );
19170 5 : SgOmpWhenClause::deleteMemoryPool( );
19171 5 : SgOmpFullClause::deleteMemoryPool( );
19172 5 : SgOmpPartialClause::deleteMemoryPool( );
19173 5 : SgOmpSizesClause::deleteMemoryPool( );
19174 5 : SgUpirBranchField::deleteMemoryPool( );
19175 5 : SgUpirNestedLevelField::deleteMemoryPool( );
19176 5 : SgUpirNestedParentField::deleteMemoryPool( );
19177 5 : SgUpirNestedChildField::deleteMemoryPool( );
19178 5 : SgUpirSyncField::deleteMemoryPool( );
19179 5 : SgUpirDataField::deleteMemoryPool( );
19180 5 : SgUpirDataItemField::deleteMemoryPool( );
19181 5 : SgUpirTargetField::deleteMemoryPool( );
19182 5 : SgOpenclAccessModeModifier::deleteMemoryPool( );
19183 5 : SgOpenStatement::deleteMemoryPool( );
19184 5 : SgOptions::deleteMemoryPool( );
19185 5 : SgOrOp::deleteMemoryPool( );
19186 5 : SgParameterStatement::deleteMemoryPool( );
19187 5 : SgPartialFunctionModifierType::deleteMemoryPool( );
19188 5 : SgPartialFunctionType::deleteMemoryPool( );
19189 5 : SgPassStatement::deleteMemoryPool( );
19190 5 : SgPlusAssignOp::deleteMemoryPool( );
19191 5 : SgPlusPlusOp::deleteMemoryPool( );
19192 5 : SgPntrArrRefExp::deleteMemoryPool( );
19193 5 : SgPointerAssignOp::deleteMemoryPool( );
19194 5 : SgPointerDerefExp::deleteMemoryPool( );
19195 5 : SgPointerMemberType::deleteMemoryPool( );
19196 5 : SgPointerType::deleteMemoryPool( );
19197 5 : SgPowerOp::deleteMemoryPool( );
19198 5 : SgPragma::deleteMemoryPool( );
19199 5 : SgPragmaDeclaration::deleteMemoryPool( );
19200 5 : SgPrintStatement::deleteMemoryPool( );
19201 5 : SgProcedureHeaderStatement::deleteMemoryPool( );
19202 5 : SgProgramHeaderStatement::deleteMemoryPool( );
19203 5 : SgProject::deleteMemoryPool( );
19204 5 : SgPseudoDestructorRefExp::deleteMemoryPool( );
19205 5 : SgQualifiedName::deleteMemoryPool( );
19206 5 : SgQualifiedNameType::deleteMemoryPool( );
19207 5 : SgRangeExp::deleteMemoryPool( );
19208 5 : SgRangeBasedForStatement::deleteMemoryPool( );
19209 5 : SgReadStatement::deleteMemoryPool( );
19210 5 : SgRealPartOp::deleteMemoryPool( );
19211 5 : SgRefExp::deleteMemoryPool( );
19212 5 : SgReferenceType::deleteMemoryPool( );
19213 5 : SgRenamePair::deleteMemoryPool( );
19214 5 : SgRenameSymbol::deleteMemoryPool( );
19215 5 : SgReturnStmt::deleteMemoryPool( );
19216 5 : SgRewindStatement::deleteMemoryPool( );
19217 5 : SgRshiftAssignOp::deleteMemoryPool( );
19218 5 : SgRshiftOp::deleteMemoryPool( );
19219 5 : SgRvalueReferenceType::deleteMemoryPool( );
19220 5 : SgScopeOp::deleteMemoryPool( );
19221 5 : SgScopeStatement::deleteMemoryPool( );
19222 5 : SgSequenceStatement::deleteMemoryPool( );
19223 5 : SgSetComprehension::deleteMemoryPool( );
19224 5 : SgShortVal::deleteMemoryPool( );
19225 5 : SgSIMDBinaryOp::deleteMemoryPool( );
19226 5 : SgSIMDAddOp::deleteMemoryPool( );
19227 5 : SgSIMDSubOp::deleteMemoryPool( );
19228 5 : SgSIMDMulOp::deleteMemoryPool( );
19229 5 : SgSIMDDivOp::deleteMemoryPool( );
19230 5 : SgSIMDFmaOp::deleteMemoryPool( );
19231 5 : SgSIMDLoad::deleteMemoryPool( );
19232 5 : SgSIMDBroadcast::deleteMemoryPool( );
19233 5 : SgSIMDStore::deleteMemoryPool( );
19234 5 : SgSIMDPartialStore::deleteMemoryPool( );
19235 5 : SgSIMDScalarStore::deleteMemoryPool( );
19236 5 : SgSIMDGather::deleteMemoryPool( );
19237 5 : SgSIMDExplicitGather::deleteMemoryPool( );
19238 5 : SgSIMDScatter::deleteMemoryPool( );
19239 5 : SgSizeOfOp::deleteMemoryPool( );
19240 5 : SgAlignOfOp::deleteMemoryPool( );
19241 5 : SgSourceFile::deleteMemoryPool( );
19242 5 : SgSpaceshipOp::deleteMemoryPool( );
19243 5 : SgSpawnStmt::deleteMemoryPool( );
19244 5 : SgSyncAllStatement::deleteMemoryPool( );
19245 5 : SgSyncImagesStatement::deleteMemoryPool( );
19246 5 : SgSyncMemoryStatement::deleteMemoryPool( );
19247 5 : SgSyncTeamStatement::deleteMemoryPool( );
19248 5 : SgLockStatement::deleteMemoryPool( );
19249 5 : SgUnlockStatement::deleteMemoryPool( );
19250 5 : SgProcessControlStatement::deleteMemoryPool( );
19251 5 : SgSpecialFunctionModifier::deleteMemoryPool( );
19252 5 : SgStatement::deleteMemoryPool( );
19253 5 : SgStaticAssertionDeclaration::deleteMemoryPool( );
19254 5 : SgStmtDeclarationStatement::deleteMemoryPool( );
19255 5 : SgStatementExpression::deleteMemoryPool( );
19256 5 : SgStatementFunctionStatement::deleteMemoryPool( );
19257 5 : SgStorageModifier::deleteMemoryPool( );
19258 5 : SgStringConversion::deleteMemoryPool( );
19259 5 : SgStringKeyedBidirectionalGraph::deleteMemoryPool( );
19260 5 : SgStringVal::deleteMemoryPool( );
19261 5 : SgStructureModifier::deleteMemoryPool( );
19262 5 : SgSubscriptExpression::deleteMemoryPool( );
19263 5 : SgSubtractOp::deleteMemoryPool( );
19264 5 : SgSupport::deleteMemoryPool( );
19265 5 : SgSwitchStatement::deleteMemoryPool( );
19266 5 : SgSymbol::deleteMemoryPool( );
19267 5 : SgSymbolTable::deleteMemoryPool( );
19268 5 : SgTemplateArgument::deleteMemoryPool( );
19269 5 : SgTemplateArgumentList::deleteMemoryPool( );
19270 5 : SgTemplateDeclaration::deleteMemoryPool( );
19271 5 : SgTemplateClassDeclaration::deleteMemoryPool( );
19272 5 : SgTemplateClassSymbol::deleteMemoryPool( );
19273 5 : SgTemplateFunctionDeclaration::deleteMemoryPool( );
19274 5 : SgTemplateFunctionRefExp::deleteMemoryPool( );
19275 5 : SgTemplateFunctionSymbol::deleteMemoryPool( );
19276 5 : SgTemplateMemberFunctionDeclaration::deleteMemoryPool( );
19277 5 : SgTemplateMemberFunctionRefExp::deleteMemoryPool( );
19278 5 : SgTemplateMemberFunctionSymbol::deleteMemoryPool( );
19279 5 : SgTemplateTypedefDeclaration::deleteMemoryPool( );
19280 5 : SgTemplateTypedefSymbol::deleteMemoryPool( );
19281 5 : SgTemplateVariableDeclaration::deleteMemoryPool( );
19282 5 : SgTemplateVariableSymbol::deleteMemoryPool( );
19283 5 : SgTemplateClassDefinition::deleteMemoryPool( );
19284 5 : SgTemplateFunctionDefinition::deleteMemoryPool( );
19285 5 : SgTemplateInstantiationDecl::deleteMemoryPool( );
19286 5 : SgTemplateInstantiationDefn::deleteMemoryPool( );
19287 5 : SgTemplateInstantiationDirectiveStatement::deleteMemoryPool( );
19288 5 : SgTemplateInstantiationFunctionDecl::deleteMemoryPool( );
19289 5 : SgTemplateInstantiationMemberFunctionDecl::deleteMemoryPool( );
19290 5 : SgTemplateInstantiationTypedefDeclaration::deleteMemoryPool( );
19291 5 : SgTemplateParameter::deleteMemoryPool( );
19292 5 : SgTemplateParameterVal::deleteMemoryPool( );
19293 5 : SgTemplateParameterList::deleteMemoryPool( );
19294 5 : SgTemplateSymbol::deleteMemoryPool( );
19295 5 : SgTemplateType::deleteMemoryPool( );
19296 5 : SgThisExp::deleteMemoryPool( );
19297 5 : SgTypeTraitBuiltinOperator::deleteMemoryPool( );
19298 5 : SgSuperExp::deleteMemoryPool( );
19299 5 : SgThrowOp::deleteMemoryPool( );
19300 5 : SgToken::deleteMemoryPool( );
19301 5 : SgTryStmt::deleteMemoryPool( );
19302 5 : SgTupleExp::deleteMemoryPool( );
19303 5 : SgType::deleteMemoryPool( );
19304 5 : SgTypeBool::deleteMemoryPool( );
19305 5 : SgTypeChar::deleteMemoryPool( );
19306 5 : SgTypeChar16::deleteMemoryPool( );
19307 5 : SgTypeChar32::deleteMemoryPool( );
19308 5 : SgTypeComplex::deleteMemoryPool( );
19309 5 : SgTypeDefault::deleteMemoryPool( );
19310 5 : SgTypeExpression::deleteMemoryPool( );
19311 5 : SgTypeLabel::deleteMemoryPool( );
19312 5 : SgTypeDouble::deleteMemoryPool( );
19313 5 : SgTypeEllipse::deleteMemoryPool( );
19314 5 : SgTypeFixed::deleteMemoryPool( );
19315 5 : SgTypeFloat::deleteMemoryPool( );
19316 5 : SgTypeFloat128::deleteMemoryPool( );
19317 5 : SgTypeFloat80::deleteMemoryPool( );
19318 5 : SgTypeGlobalVoid::deleteMemoryPool( );
19319 5 : SgTypeIdOp::deleteMemoryPool( );
19320 5 : SgTypeImaginary::deleteMemoryPool( );
19321 5 : SgTypeInt::deleteMemoryPool( );
19322 5 : SgTypeLong::deleteMemoryPool( );
19323 5 : SgTypeLongDouble::deleteMemoryPool( );
19324 5 : SgTypeLongLong::deleteMemoryPool( );
19325 5 : SgTypeModifier::deleteMemoryPool( );
19326 5 : SgTypeMatrix::deleteMemoryPool( );
19327 5 : SgTypeTuple::deleteMemoryPool( );
19328 5 : SgTypeNullptr::deleteMemoryPool( );
19329 5 : SgTypeOfType::deleteMemoryPool( );
19330 5 : SgTypeShort::deleteMemoryPool( );
19331 5 : SgTypeSigned128bitInteger::deleteMemoryPool( );
19332 5 : SgTypeSignedChar::deleteMemoryPool( );
19333 5 : SgTypeSignedInt::deleteMemoryPool( );
19334 5 : SgTypeSignedLong::deleteMemoryPool( );
19335 5 : SgTypeSignedLongLong::deleteMemoryPool( );
19336 5 : SgTypeSignedShort::deleteMemoryPool( );
19337 5 : SgTypeString::deleteMemoryPool( );
19338 5 : SgTypeUnknown::deleteMemoryPool( );
19339 5 : SgTypeUnsigned128bitInteger::deleteMemoryPool( );
19340 5 : SgTypeUnsignedChar::deleteMemoryPool( );
19341 5 : SgTypeUnsignedInt::deleteMemoryPool( );
19342 5 : SgTypeUnsignedLong::deleteMemoryPool( );
19343 5 : SgTypeUnsignedLongLong::deleteMemoryPool( );
19344 5 : SgTypeUnsignedShort::deleteMemoryPool( );
19345 5 : SgTypeVoid::deleteMemoryPool( );
19346 5 : SgTypeWchar::deleteMemoryPool( );
19347 5 : SgTypedefDeclaration::deleteMemoryPool( );
19348 5 : SgTypedefSeq::deleteMemoryPool( );
19349 5 : SgTypedefSymbol::deleteMemoryPool( );
19350 5 : SgTypedefType::deleteMemoryPool( );
19351 5 : SgUPC_AccessModifier::deleteMemoryPool( );
19352 5 : SgUnaryAddOp::deleteMemoryPool( );
19353 5 : SgUnaryOp::deleteMemoryPool( );
19354 5 : SgUndefDirectiveStatement::deleteMemoryPool( );
19355 5 : SgUndirectedGraphEdge::deleteMemoryPool( );
19356 5 : SgUnknownArrayOrFunctionReference::deleteMemoryPool( );
19357 5 : SgUnknownFile::deleteMemoryPool( );
19358 5 : SgUnparse_Info::deleteMemoryPool( );
19359 5 : SgUnsignedCharVal::deleteMemoryPool( );
19360 5 : SgUnsignedIntVal::deleteMemoryPool( );
19361 5 : SgUnsignedLongLongIntVal::deleteMemoryPool( );
19362 5 : SgUnsignedLongVal::deleteMemoryPool( );
19363 5 : SgUnsignedShortVal::deleteMemoryPool( );
19364 5 : SgUpcBarrierStatement::deleteMemoryPool( );
19365 5 : SgUpcBlocksizeofExpression::deleteMemoryPool( );
19366 5 : SgUpcElemsizeofExpression::deleteMemoryPool( );
19367 5 : SgUpcFenceStatement::deleteMemoryPool( );
19368 5 : SgUpcForAllStatement::deleteMemoryPool( );
19369 5 : SgUpcLocalsizeofExpression::deleteMemoryPool( );
19370 5 : SgUpcMythread::deleteMemoryPool( );
19371 5 : SgUpcNotifyStatement::deleteMemoryPool( );
19372 5 : SgUpcThreads::deleteMemoryPool( );
19373 5 : SgUpcWaitStatement::deleteMemoryPool( );
19374 5 : SgUseStatement::deleteMemoryPool( );
19375 5 : SgUserDefinedBinaryOp::deleteMemoryPool( );
19376 5 : SgUserDefinedUnaryOp::deleteMemoryPool( );
19377 5 : SgUsingDeclarationStatement::deleteMemoryPool( );
19378 5 : SgUsingDirectiveStatement::deleteMemoryPool( );
19379 5 : SgValueExp::deleteMemoryPool( );
19380 5 : SgVarArgCopyOp::deleteMemoryPool( );
19381 5 : SgVarArgEndOp::deleteMemoryPool( );
19382 5 : SgVarArgOp::deleteMemoryPool( );
19383 5 : SgVarArgStartOneOperandOp::deleteMemoryPool( );
19384 5 : SgVarArgStartOp::deleteMemoryPool( );
19385 5 : SgVarRefExp::deleteMemoryPool( );
19386 5 : SgVariableDeclaration::deleteMemoryPool( );
19387 5 : SgVariableDefinition::deleteMemoryPool( );
19388 5 : SgVariableSymbol::deleteMemoryPool( );
19389 5 : SgVariantExpression::deleteMemoryPool( );
19390 5 : SgVariantStatement::deleteMemoryPool( );
19391 5 : SgVoidVal::deleteMemoryPool( );
19392 5 : SgWaitStatement::deleteMemoryPool( );
19393 5 : SgWarningDirectiveStatement::deleteMemoryPool( );
19394 5 : SgWithStatement::deleteMemoryPool( );
19395 5 : SgWcharVal::deleteMemoryPool( );
19396 5 : SgWhereStatement::deleteMemoryPool( );
19397 5 : SgWhileStmt::deleteMemoryPool( );
19398 5 : SgWriteStatement::deleteMemoryPool( );
19399 5 : SgXorAssignOp::deleteMemoryPool( );
19400 5 : SgYieldExpression::deleteMemoryPool( );
19401 5 : Sg_File_Info::deleteMemoryPool( );
19402 5 : SgTypeCAFTeam::deleteMemoryPool( );
19403 5 : SgCAFWithTeamStatement::deleteMemoryPool( );
19404 5 : SgCAFCoExpression::deleteMemoryPool( );
19405 5 : SgCallExpression::deleteMemoryPool( );
19406 5 : SgTypeCrayPointer::deleteMemoryPool( );
19407 5 : SgClassExp::deleteMemoryPool( );
19408 :
19409 : /* #line 373 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
19410 :
19411 5 : SgNode::all_pools.clear();
19412 :
19413 5 : }
19414 :
19415 : void
19416 0 : AST_FILE_IO :: deleteStaticData ( )
19417 : {
19418 0 : SgNode::p_globalFunctionTypeTable = NULL ;
19419 0 : SgNode::p_globalTypeTable = NULL ;
19420 0 : SgNode::p_globalMangledNameMap.clear();
19421 0 : SgNode::p_shortMangledNameCache.clear();
19422 0 : SgNode::p_globalQualifiedNameMapForNames.clear();
19423 0 : SgNode::p_globalQualifiedNameMapForTypes.clear();
19424 0 : SgNode::p_globalQualifiedNameMapForTemplateHeaders.clear();
19425 0 : SgNode::p_globalTypeNameMap.clear();
19426 0 : SgNode::p_globalQualifiedNameMapForMapsOfTypes.clear();
19427 0 : SgSymbolTable::p_force_search_of_base_classes = (bool)(0);
19428 0 : Sg_File_Info::p_fileidtoname_map.clear();
19429 0 : Sg_File_Info::p_nametofileid_map.clear();
19430 0 : SgFile::p_skip_unparse_asm_commands = (bool)(0);
19431 0 : SgFile::p_header_file_unparsing_optimization = (bool)(0);
19432 0 : SgUnparse_Info::p_forceDefaultConstructorToTriggerError = (bool)(0);
19433 0 : SgUnparse_Info::p_extern_C_with_braces = (bool)(0);
19434 0 : SgGraph::p_index_counter = (int)(0);
19435 0 : SgGraphNode::p_index_counter = (int)(0);
19436 0 : SgGraphEdge::p_index_counter = (int)(0);
19437 0 : SgTypeUnknown::p_builtin_type = NULL ;
19438 0 : SgTypeChar::p_builtin_type = NULL ;
19439 0 : SgTypeSignedChar::p_builtin_type = NULL ;
19440 0 : SgTypeUnsignedChar::p_builtin_type = NULL ;
19441 0 : SgTypeShort::p_builtin_type = NULL ;
19442 0 : SgTypeSignedShort::p_builtin_type = NULL ;
19443 0 : SgTypeUnsignedShort::p_builtin_type = NULL ;
19444 0 : SgTypeInt::p_builtin_type = NULL ;
19445 0 : SgTypeSignedInt::p_builtin_type = NULL ;
19446 0 : SgTypeUnsignedInt::p_builtin_type = NULL ;
19447 0 : SgTypeLong::p_builtin_type = NULL ;
19448 0 : SgTypeSignedLong::p_builtin_type = NULL ;
19449 0 : SgTypeUnsignedLong::p_builtin_type = NULL ;
19450 0 : SgTypeVoid::p_builtin_type = NULL ;
19451 0 : SgTypeGlobalVoid::p_builtin_type = NULL ;
19452 0 : SgTypeWchar::p_builtin_type = NULL ;
19453 0 : SgTypeFloat::p_builtin_type = NULL ;
19454 0 : SgTypeDouble::p_builtin_type = NULL ;
19455 0 : SgTypeLongLong::p_builtin_type = NULL ;
19456 0 : SgTypeSignedLongLong::p_builtin_type = NULL ;
19457 0 : SgTypeUnsignedLongLong::p_builtin_type = NULL ;
19458 0 : SgTypeSigned128bitInteger::p_builtin_type = NULL ;
19459 0 : SgTypeUnsigned128bitInteger::p_builtin_type = NULL ;
19460 0 : SgTypeFloat80::p_builtin_type = NULL ;
19461 0 : SgTypeLongDouble::p_builtin_type = NULL ;
19462 0 : SgTypeBool::p_builtin_type = NULL ;
19463 0 : SgNamedType::p_builtin_type = NULL ;
19464 0 : SgPartialFunctionModifierType::p_builtin_type = NULL ;
19465 0 : SgTypeEllipse::p_builtin_type = NULL ;
19466 0 : SgTypeDefault::p_builtin_type = NULL ;
19467 0 : SgTypeCAFTeam::p_builtin_type = NULL ;
19468 0 : SgTypeCrayPointer::p_builtin_type = NULL ;
19469 0 : SgTypeLabel::p_builtin_type = NULL ;
19470 0 : SgTypeNullptr::p_builtin_type = NULL ;
19471 0 : SgTypeMatrix::p_builtin_type = NULL ;
19472 0 : SgTypeTuple::p_builtin_type = NULL ;
19473 0 : SgTypeChar16::p_builtin_type = NULL ;
19474 0 : SgTypeChar32::p_builtin_type = NULL ;
19475 0 : SgTypeFloat128::p_builtin_type = NULL ;
19476 :
19477 : /* #line 382 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
19478 :
19479 : /* JH (02/03/2006) since the memory pool contain no data anymore, we reset the
19480 : contents of the listOfMemoryPoolSizes to 0!
19481 : */
19482 0 : return;
19483 : }
19484 :
19485 : /* JH (01/03/2006) This mehtods steps through all memory pools and extends it to that amount it
19486 : will have after the AST was rebuilt. Thereby, we can set the pointers, even if there is no
19487 : valid data at the address they are pointing to. But it will be!
19488 : */
19489 : void
19490 2 : AST_FILE_IO :: extendMemoryPoolsForRebuildingAST ( )
19491 : {
19492 2 : assert ( freepointersOfCurrentAstAreSetToGlobalIndices == false );
19493 2 : assert ( 0 < getTotalNumberOfNodesOfNewAst( ) );
19494 :
19495 2 : SgAccessModifier::extendMemoryPoolForFileIO( );
19496 2 : SgActualArgumentExpression::extendMemoryPoolForFileIO( );
19497 2 : SgAddOp::extendMemoryPoolForFileIO( );
19498 2 : SgAddressOfOp::extendMemoryPoolForFileIO( );
19499 2 : SgAggregateInitializer::extendMemoryPoolForFileIO( );
19500 2 : SgAliasSymbol::extendMemoryPoolForFileIO( );
19501 2 : SgAllocateStatement::extendMemoryPoolForFileIO( );
19502 2 : SgAndAssignOp::extendMemoryPoolForFileIO( );
19503 2 : SgAndOp::extendMemoryPoolForFileIO( );
19504 2 : SgArithmeticIfStatement::extendMemoryPoolForFileIO( );
19505 2 : SgArrayType::extendMemoryPoolForFileIO( );
19506 2 : SgArrowExp::extendMemoryPoolForFileIO( );
19507 2 : SgArrowStarOp::extendMemoryPoolForFileIO( );
19508 2 : SgAsmOp::extendMemoryPoolForFileIO( );
19509 2 : SgAsmStmt::extendMemoryPoolForFileIO( );
19510 2 : SgAssertStmt::extendMemoryPoolForFileIO( );
19511 2 : SgAssignInitializer::extendMemoryPoolForFileIO( );
19512 2 : SgAssignOp::extendMemoryPoolForFileIO( );
19513 2 : SgAssignStatement::extendMemoryPoolForFileIO( );
19514 2 : SgAssignedGotoStatement::extendMemoryPoolForFileIO( );
19515 2 : SgAssociateStatement::extendMemoryPoolForFileIO( );
19516 2 : SgAsteriskShapeExp::extendMemoryPoolForFileIO( );
19517 2 : SgAttribute::extendMemoryPoolForFileIO( );
19518 2 : SgAttributeSpecificationStatement::extendMemoryPoolForFileIO( );
19519 2 : SgAutoType::extendMemoryPoolForFileIO( );
19520 2 : SgAwaitExpression::extendMemoryPoolForFileIO( );
19521 2 : SgBackspaceStatement::extendMemoryPoolForFileIO( );
19522 2 : SgBaseClass::extendMemoryPoolForFileIO( );
19523 2 : SgExpBaseClass::extendMemoryPoolForFileIO( );
19524 2 : SgBaseClassModifier::extendMemoryPoolForFileIO( );
19525 2 : SgBasicBlock::extendMemoryPoolForFileIO( );
19526 2 : SgBidirectionalGraph::extendMemoryPoolForFileIO( );
19527 2 : SgBinaryOp::extendMemoryPoolForFileIO( );
19528 2 : SgBitAndOp::extendMemoryPoolForFileIO( );
19529 2 : SgBitAttribute::extendMemoryPoolForFileIO( );
19530 2 : SgBitComplementOp::extendMemoryPoolForFileIO( );
19531 2 : SgBitEqvOp::extendMemoryPoolForFileIO( );
19532 2 : SgBitOrOp::extendMemoryPoolForFileIO( );
19533 2 : SgBitXorOp::extendMemoryPoolForFileIO( );
19534 2 : SgBlockDataStatement::extendMemoryPoolForFileIO( );
19535 2 : SgBoolValExp::extendMemoryPoolForFileIO( );
19536 2 : SgBreakStmt::extendMemoryPoolForFileIO( );
19537 2 : SgBracedInitializer::extendMemoryPoolForFileIO( );
19538 2 : SgC_PreprocessorDirectiveStatement::extendMemoryPoolForFileIO( );
19539 2 : SgCaseOptionStmt::extendMemoryPoolForFileIO( );
19540 2 : SgCastExp::extendMemoryPoolForFileIO( );
19541 2 : SgCatchOptionStmt::extendMemoryPoolForFileIO( );
19542 2 : SgCatchStatementSeq::extendMemoryPoolForFileIO( );
19543 2 : SgCharVal::extendMemoryPoolForFileIO( );
19544 2 : SgChar16Val::extendMemoryPoolForFileIO( );
19545 2 : SgChar32Val::extendMemoryPoolForFileIO( );
19546 2 : SgChooseExpression::extendMemoryPoolForFileIO( );
19547 2 : SgClassDecl_attr::extendMemoryPoolForFileIO( );
19548 2 : SgClassDeclaration::extendMemoryPoolForFileIO( );
19549 2 : SgClassDefinition::extendMemoryPoolForFileIO( );
19550 2 : SgClassNameRefExp::extendMemoryPoolForFileIO( );
19551 2 : SgClassSymbol::extendMemoryPoolForFileIO( );
19552 2 : SgClassType::extendMemoryPoolForFileIO( );
19553 2 : SgClinkageDeclarationStatement::extendMemoryPoolForFileIO( );
19554 2 : SgClinkageEndStatement::extendMemoryPoolForFileIO( );
19555 2 : SgClinkageStartStatement::extendMemoryPoolForFileIO( );
19556 2 : SgCloseStatement::extendMemoryPoolForFileIO( );
19557 2 : SgColonShapeExp::extendMemoryPoolForFileIO( );
19558 2 : SgCommaOpExp::extendMemoryPoolForFileIO( );
19559 2 : SgCommonBlock::extendMemoryPoolForFileIO( );
19560 2 : SgCommonBlockObject::extendMemoryPoolForFileIO( );
19561 2 : SgCommonSymbol::extendMemoryPoolForFileIO( );
19562 2 : SgComplexVal::extendMemoryPoolForFileIO( );
19563 2 : SgComprehension::extendMemoryPoolForFileIO( );
19564 2 : SgCompoundAssignOp::extendMemoryPoolForFileIO( );
19565 2 : SgCompoundInitializer::extendMemoryPoolForFileIO( );
19566 2 : SgCompoundLiteralExp::extendMemoryPoolForFileIO( );
19567 2 : SgComputedGotoStatement::extendMemoryPoolForFileIO( );
19568 2 : SgConcatenationOp::extendMemoryPoolForFileIO( );
19569 2 : SgConditionalExp::extendMemoryPoolForFileIO( );
19570 2 : SgConjugateOp::extendMemoryPoolForFileIO( );
19571 2 : SgConstVolatileModifier::extendMemoryPoolForFileIO( );
19572 2 : SgConstructorInitializer::extendMemoryPoolForFileIO( );
19573 2 : SgContainsStatement::extendMemoryPoolForFileIO( );
19574 2 : SgContinueStmt::extendMemoryPoolForFileIO( );
19575 2 : SgCtorInitializerList::extendMemoryPoolForFileIO( );
19576 2 : SgDataStatementGroup::extendMemoryPoolForFileIO( );
19577 2 : SgDataStatementObject::extendMemoryPoolForFileIO( );
19578 2 : SgDataStatementValue::extendMemoryPoolForFileIO( );
19579 2 : SgDeadIfDirectiveStatement::extendMemoryPoolForFileIO( );
19580 2 : SgDeallocateStatement::extendMemoryPoolForFileIO( );
19581 2 : SgDeclarationModifier::extendMemoryPoolForFileIO( );
19582 2 : SgDeclarationScope::extendMemoryPoolForFileIO( );
19583 2 : SgDeclarationStatement::extendMemoryPoolForFileIO( );
19584 2 : SgDeclType::extendMemoryPoolForFileIO( );
19585 2 : SgDefaultOptionStmt::extendMemoryPoolForFileIO( );
19586 2 : SgDefaultSymbol::extendMemoryPoolForFileIO( );
19587 2 : SgDefineDirectiveStatement::extendMemoryPoolForFileIO( );
19588 2 : SgDeleteExp::extendMemoryPoolForFileIO( );
19589 2 : SgDerivedTypeStatement::extendMemoryPoolForFileIO( );
19590 2 : SgDesignatedInitializer::extendMemoryPoolForFileIO( );
19591 2 : SgDictionaryComprehension::extendMemoryPoolForFileIO( );
19592 2 : SgDictionaryExp::extendMemoryPoolForFileIO( );
19593 2 : SgDimensionObject::extendMemoryPoolForFileIO( );
19594 2 : SgDirectedGraphEdge::extendMemoryPoolForFileIO( );
19595 2 : SgDirectory::extendMemoryPoolForFileIO( );
19596 2 : SgDirectoryList::extendMemoryPoolForFileIO( );
19597 2 : SgDivAssignOp::extendMemoryPoolForFileIO( );
19598 2 : SgDivideOp::extendMemoryPoolForFileIO( );
19599 2 : SgDoWhileStmt::extendMemoryPoolForFileIO( );
19600 2 : SgDotExp::extendMemoryPoolForFileIO( );
19601 2 : SgDotStarOp::extendMemoryPoolForFileIO( );
19602 2 : SgDoubleVal::extendMemoryPoolForFileIO( );
19603 2 : SgElaboratedTypeModifier::extendMemoryPoolForFileIO( );
19604 2 : SgElementwiseOp::extendMemoryPoolForFileIO( );
19605 2 : SgElementwiseAddOp::extendMemoryPoolForFileIO( );
19606 2 : SgElementwiseDivideOp::extendMemoryPoolForFileIO( );
19607 2 : SgElementwiseLeftDivideOp::extendMemoryPoolForFileIO( );
19608 2 : SgElementwiseMultiplyOp::extendMemoryPoolForFileIO( );
19609 2 : SgElementwisePowerOp::extendMemoryPoolForFileIO( );
19610 2 : SgElementwiseSubtractOp::extendMemoryPoolForFileIO( );
19611 2 : SgElseDirectiveStatement::extendMemoryPoolForFileIO( );
19612 2 : SgElseWhereStatement::extendMemoryPoolForFileIO( );
19613 2 : SgElseifDirectiveStatement::extendMemoryPoolForFileIO( );
19614 2 : SgEmptyDeclaration::extendMemoryPoolForFileIO( );
19615 2 : SgEmptyDirectiveStatement::extendMemoryPoolForFileIO( );
19616 2 : SgEndfileStatement::extendMemoryPoolForFileIO( );
19617 2 : SgEndifDirectiveStatement::extendMemoryPoolForFileIO( );
19618 2 : SgEntryStatement::extendMemoryPoolForFileIO( );
19619 2 : SgEnumDeclaration::extendMemoryPoolForFileIO( );
19620 2 : SgEnumFieldSymbol::extendMemoryPoolForFileIO( );
19621 2 : SgEnumSymbol::extendMemoryPoolForFileIO( );
19622 2 : SgEnumType::extendMemoryPoolForFileIO( );
19623 2 : SgEnumVal::extendMemoryPoolForFileIO( );
19624 2 : SgEqualityOp::extendMemoryPoolForFileIO( );
19625 2 : SgEquivalenceStatement::extendMemoryPoolForFileIO( );
19626 2 : SgErrorDirectiveStatement::extendMemoryPoolForFileIO( );
19627 2 : SgExecStatement::extendMemoryPoolForFileIO( );
19628 2 : SgExponentiationOp::extendMemoryPoolForFileIO( );
19629 2 : SgExponentiationAssignOp::extendMemoryPoolForFileIO( );
19630 2 : SgExprListExp::extendMemoryPoolForFileIO( );
19631 2 : SgExprStatement::extendMemoryPoolForFileIO( );
19632 2 : SgExpression::extendMemoryPoolForFileIO( );
19633 2 : SgExpressionRoot::extendMemoryPoolForFileIO( );
19634 2 : SgFile::extendMemoryPoolForFileIO( );
19635 2 : SgFileList::extendMemoryPoolForFileIO( );
19636 2 : SgFloatVal::extendMemoryPoolForFileIO( );
19637 2 : SgFloat128Val::extendMemoryPoolForFileIO( );
19638 2 : SgFloat80Val::extendMemoryPoolForFileIO( );
19639 2 : SgFoldExpression::extendMemoryPoolForFileIO( );
19640 2 : SgFlushStatement::extendMemoryPoolForFileIO( );
19641 2 : SgForAllStatement::extendMemoryPoolForFileIO( );
19642 2 : SgForInitStatement::extendMemoryPoolForFileIO( );
19643 2 : SgForStatement::extendMemoryPoolForFileIO( );
19644 2 : SgFormatItem::extendMemoryPoolForFileIO( );
19645 2 : SgFormatItemList::extendMemoryPoolForFileIO( );
19646 2 : SgFormatStatement::extendMemoryPoolForFileIO( );
19647 2 : SgFortranDo::extendMemoryPoolForFileIO( );
19648 2 : SgFortranIncludeLine::extendMemoryPoolForFileIO( );
19649 2 : SgFortranNonblockedDo::extendMemoryPoolForFileIO( );
19650 2 : SgFuncDecl_attr::extendMemoryPoolForFileIO( );
19651 2 : SgFunctionCallExp::extendMemoryPoolForFileIO( );
19652 2 : SgFunctionDeclaration::extendMemoryPoolForFileIO( );
19653 2 : SgFunctionDefinition::extendMemoryPoolForFileIO( );
19654 2 : SgFunctionParameterScope::extendMemoryPoolForFileIO( );
19655 2 : SgFunctionModifier::extendMemoryPoolForFileIO( );
19656 2 : SgFunctionParameterList::extendMemoryPoolForFileIO( );
19657 2 : SgFunctionParameterRefExp::extendMemoryPoolForFileIO( );
19658 2 : SgFunctionParameterTypeList::extendMemoryPoolForFileIO( );
19659 2 : SgFunctionRefExp::extendMemoryPoolForFileIO( );
19660 2 : SgFunctionSymbol::extendMemoryPoolForFileIO( );
19661 2 : SgFunctionType::extendMemoryPoolForFileIO( );
19662 2 : SgFunctionTypeSymbol::extendMemoryPoolForFileIO( );
19663 2 : SgFunctionTypeTable::extendMemoryPoolForFileIO( );
19664 2 : SgTypeTable::extendMemoryPoolForFileIO( );
19665 2 : SgGlobal::extendMemoryPoolForFileIO( );
19666 2 : SgGotoStatement::extendMemoryPoolForFileIO( );
19667 2 : SgGraph::extendMemoryPoolForFileIO( );
19668 2 : SgGraphEdge::extendMemoryPoolForFileIO( );
19669 2 : SgGraphEdgeList::extendMemoryPoolForFileIO( );
19670 2 : SgGraphNode::extendMemoryPoolForFileIO( );
19671 2 : SgGraphNodeList::extendMemoryPoolForFileIO( );
19672 2 : SgGreaterOrEqualOp::extendMemoryPoolForFileIO( );
19673 2 : SgGreaterThanOp::extendMemoryPoolForFileIO( );
19674 2 : SgIOItemExpression::extendMemoryPoolForFileIO( );
19675 2 : SgIOStatement::extendMemoryPoolForFileIO( );
19676 2 : SgIdentDirectiveStatement::extendMemoryPoolForFileIO( );
19677 2 : SgIfDirectiveStatement::extendMemoryPoolForFileIO( );
19678 2 : SgIfStmt::extendMemoryPoolForFileIO( );
19679 2 : SgIfdefDirectiveStatement::extendMemoryPoolForFileIO( );
19680 2 : SgIfndefDirectiveStatement::extendMemoryPoolForFileIO( );
19681 2 : SgImageControlStatement::extendMemoryPoolForFileIO( );
19682 2 : SgImagPartOp::extendMemoryPoolForFileIO( );
19683 2 : SgImplicitStatement::extendMemoryPoolForFileIO( );
19684 2 : SgImpliedDo::extendMemoryPoolForFileIO( );
19685 2 : SgImportStatement::extendMemoryPoolForFileIO( );
19686 2 : SgIncidenceDirectedGraph::extendMemoryPoolForFileIO( );
19687 2 : SgIncidenceUndirectedGraph::extendMemoryPoolForFileIO( );
19688 2 : SgIncludeDirectiveStatement::extendMemoryPoolForFileIO( );
19689 2 : SgIncludeFile::extendMemoryPoolForFileIO( );
19690 2 : SgIncludeNextDirectiveStatement::extendMemoryPoolForFileIO( );
19691 2 : SgInitializedName::extendMemoryPoolForFileIO( );
19692 2 : SgInitializer::extendMemoryPoolForFileIO( );
19693 2 : SgInquireStatement::extendMemoryPoolForFileIO( );
19694 2 : SgIntKeyedBidirectionalGraph::extendMemoryPoolForFileIO( );
19695 2 : SgIntVal::extendMemoryPoolForFileIO( );
19696 2 : SgIntegerDivideOp::extendMemoryPoolForFileIO( );
19697 2 : SgIntegerDivideAssignOp::extendMemoryPoolForFileIO( );
19698 2 : SgInterfaceBody::extendMemoryPoolForFileIO( );
19699 2 : SgHeaderFileBody::extendMemoryPoolForFileIO( );
19700 2 : SgHeaderFileReport::extendMemoryPoolForFileIO( );
19701 2 : SgInterfaceStatement::extendMemoryPoolForFileIO( );
19702 2 : SgInterfaceSymbol::extendMemoryPoolForFileIO( );
19703 2 : SgIntrinsicSymbol::extendMemoryPoolForFileIO( );
19704 2 : SgIsOp::extendMemoryPoolForFileIO( );
19705 2 : SgIsNotOp::extendMemoryPoolForFileIO( );
19706 2 : SgIorAssignOp::extendMemoryPoolForFileIO( );
19707 2 : SgKeyDatumPair::extendMemoryPoolForFileIO( );
19708 2 : SgCudaKernelExecConfig::extendMemoryPoolForFileIO( );
19709 2 : SgCudaKernelCallExp::extendMemoryPoolForFileIO( );
19710 2 : SgLabelRefExp::extendMemoryPoolForFileIO( );
19711 2 : SgLabelStatement::extendMemoryPoolForFileIO( );
19712 2 : SgLabelSymbol::extendMemoryPoolForFileIO( );
19713 2 : SgLambdaCapture::extendMemoryPoolForFileIO( );
19714 2 : SgLambdaCaptureList::extendMemoryPoolForFileIO( );
19715 2 : SgLambdaExp::extendMemoryPoolForFileIO( );
19716 2 : SgLambdaRefExp::extendMemoryPoolForFileIO( );
19717 2 : SgLeftDivideOp::extendMemoryPoolForFileIO( );
19718 2 : SgLessOrEqualOp::extendMemoryPoolForFileIO( );
19719 2 : SgLessThanOp::extendMemoryPoolForFileIO( );
19720 2 : SgLineDirectiveStatement::extendMemoryPoolForFileIO( );
19721 2 : SgLinemarkerDirectiveStatement::extendMemoryPoolForFileIO( );
19722 2 : SgLinkageModifier::extendMemoryPoolForFileIO( );
19723 2 : SgListComprehension::extendMemoryPoolForFileIO( );
19724 2 : SgListExp::extendMemoryPoolForFileIO( );
19725 2 : SgLocatedNode::extendMemoryPoolForFileIO( );
19726 2 : SgLocatedNodeSupport::extendMemoryPoolForFileIO( );
19727 2 : SgLongDoubleVal::extendMemoryPoolForFileIO( );
19728 2 : SgLongIntVal::extendMemoryPoolForFileIO( );
19729 2 : SgLongLongIntVal::extendMemoryPoolForFileIO( );
19730 2 : SgLshiftAssignOp::extendMemoryPoolForFileIO( );
19731 2 : SgLshiftOp::extendMemoryPoolForFileIO( );
19732 2 : SgMagicColonExp::extendMemoryPoolForFileIO( );
19733 2 : SgMatrixExp::extendMemoryPoolForFileIO( );
19734 2 : SgMatrixTransposeOp::extendMemoryPoolForFileIO( );
19735 2 : SgMemberFunctionDeclaration::extendMemoryPoolForFileIO( );
19736 2 : SgMemberFunctionRefExp::extendMemoryPoolForFileIO( );
19737 2 : SgMemberFunctionSymbol::extendMemoryPoolForFileIO( );
19738 2 : SgMemberFunctionType::extendMemoryPoolForFileIO( );
19739 2 : SgMembershipOp::extendMemoryPoolForFileIO( );
19740 2 : SgMicrosoftAttributeDeclaration::extendMemoryPoolForFileIO( );
19741 2 : SgMinusAssignOp::extendMemoryPoolForFileIO( );
19742 2 : SgMinusMinusOp::extendMemoryPoolForFileIO( );
19743 2 : SgMinusOp::extendMemoryPoolForFileIO( );
19744 2 : SgModAssignOp::extendMemoryPoolForFileIO( );
19745 2 : SgModOp::extendMemoryPoolForFileIO( );
19746 2 : SgModifier::extendMemoryPoolForFileIO( );
19747 2 : SgModifierNodes::extendMemoryPoolForFileIO( );
19748 2 : SgModifierType::extendMemoryPoolForFileIO( );
19749 2 : SgModuleStatement::extendMemoryPoolForFileIO( );
19750 2 : SgModuleSymbol::extendMemoryPoolForFileIO( );
19751 2 : SgMultAssignOp::extendMemoryPoolForFileIO( );
19752 2 : SgMultiplyOp::extendMemoryPoolForFileIO( );
19753 2 : SgName::extendMemoryPoolForFileIO( );
19754 2 : SgNameGroup::extendMemoryPoolForFileIO( );
19755 2 : SgNamedType::extendMemoryPoolForFileIO( );
19756 2 : SgNamelistStatement::extendMemoryPoolForFileIO( );
19757 2 : SgNamespaceAliasDeclarationStatement::extendMemoryPoolForFileIO( );
19758 2 : SgNamespaceDeclarationStatement::extendMemoryPoolForFileIO( );
19759 2 : SgNamespaceDefinitionStatement::extendMemoryPoolForFileIO( );
19760 2 : SgNamespaceSymbol::extendMemoryPoolForFileIO( );
19761 2 : SgNaryOp::extendMemoryPoolForFileIO( );
19762 2 : SgNaryBooleanOp::extendMemoryPoolForFileIO( );
19763 2 : SgNaryComparisonOp::extendMemoryPoolForFileIO( );
19764 2 : SgNewExp::extendMemoryPoolForFileIO( );
19765 2 : SgNode::extendMemoryPoolForFileIO( );
19766 2 : SgNoexceptOp::extendMemoryPoolForFileIO( );
19767 2 : SgNotEqualOp::extendMemoryPoolForFileIO( );
19768 2 : SgNotOp::extendMemoryPoolForFileIO( );
19769 2 : SgNonMembershipOp::extendMemoryPoolForFileIO( );
19770 2 : SgNonrealDecl::extendMemoryPoolForFileIO( );
19771 2 : SgNonrealRefExp::extendMemoryPoolForFileIO( );
19772 2 : SgNonrealSymbol::extendMemoryPoolForFileIO( );
19773 2 : SgNonrealType::extendMemoryPoolForFileIO( );
19774 2 : SgNonrealBaseClass::extendMemoryPoolForFileIO( );
19775 2 : SgNullExpression::extendMemoryPoolForFileIO( );
19776 2 : SgNullptrValExp::extendMemoryPoolForFileIO( );
19777 2 : SgNullStatement::extendMemoryPoolForFileIO( );
19778 2 : SgNullifyStatement::extendMemoryPoolForFileIO( );
19779 2 : SgOmpAtomicStatement::extendMemoryPoolForFileIO( );
19780 2 : SgOmpBarrierStatement::extendMemoryPoolForFileIO( );
19781 2 : SgOmpCriticalStatement::extendMemoryPoolForFileIO( );
19782 2 : SgUpirFieldBodyStatement::extendMemoryPoolForFileIO( );
19783 2 : SgUpirBodyStatement::extendMemoryPoolForFileIO( );
19784 2 : SgUpirFieldStatement::extendMemoryPoolForFileIO( );
19785 2 : SgOmpDoStatement::extendMemoryPoolForFileIO( );
19786 2 : SgOmpFlushStatement::extendMemoryPoolForFileIO( );
19787 2 : SgOmpAllocateStatement::extendMemoryPoolForFileIO( );
19788 2 : SgOmpDeclareSimdStatement::extendMemoryPoolForFileIO( );
19789 2 : SgUpirWorksharingStatement::extendMemoryPoolForFileIO( );
19790 2 : SgOmpForSimdStatement::extendMemoryPoolForFileIO( );
19791 2 : SgOmpMasterStatement::extendMemoryPoolForFileIO( );
19792 2 : SgOmpTaskyieldStatement::extendMemoryPoolForFileIO( );
19793 2 : SgOmpMetadirectiveStatement::extendMemoryPoolForFileIO( );
19794 2 : SgOmpOrderedStatement::extendMemoryPoolForFileIO( );
19795 2 : SgOmpOrderedDependStatement::extendMemoryPoolForFileIO( );
19796 2 : SgUpirSpmdStatement::extendMemoryPoolForFileIO( );
19797 2 : SgOmpTeamsStatement::extendMemoryPoolForFileIO( );
19798 2 : SgOmpCancellationPointStatement::extendMemoryPoolForFileIO( );
19799 2 : SgOmpDeclareMapperStatement::extendMemoryPoolForFileIO( );
19800 2 : SgOmpCancelStatement::extendMemoryPoolForFileIO( );
19801 2 : SgOmpTaskgroupStatement::extendMemoryPoolForFileIO( );
19802 2 : SgOmpDepobjStatement::extendMemoryPoolForFileIO( );
19803 2 : SgOmpDistributeStatement::extendMemoryPoolForFileIO( );
19804 2 : SgOmpLoopStatement::extendMemoryPoolForFileIO( );
19805 2 : SgOmpScanStatement::extendMemoryPoolForFileIO( );
19806 2 : SgOmpTaskloopStatement::extendMemoryPoolForFileIO( );
19807 2 : SgOmpTargetEnterDataStatement::extendMemoryPoolForFileIO( );
19808 2 : SgOmpTargetExitDataStatement::extendMemoryPoolForFileIO( );
19809 2 : SgOmpSectionStatement::extendMemoryPoolForFileIO( );
19810 2 : SgOmpSectionsStatement::extendMemoryPoolForFileIO( );
19811 2 : SgOmpSingleStatement::extendMemoryPoolForFileIO( );
19812 2 : SgOmpTaskStatement::extendMemoryPoolForFileIO( );
19813 2 : SgOmpTaskwaitStatement::extendMemoryPoolForFileIO( );
19814 2 : SgOmpThreadprivateStatement::extendMemoryPoolForFileIO( );
19815 2 : SgOmpWorkshareStatement::extendMemoryPoolForFileIO( );
19816 2 : SgUpirTaskStatement::extendMemoryPoolForFileIO( );
19817 2 : SgOmpTargetDataStatement::extendMemoryPoolForFileIO( );
19818 2 : SgOmpTargetParallelForStatement::extendMemoryPoolForFileIO( );
19819 2 : SgOmpTargetUpdateStatement::extendMemoryPoolForFileIO( );
19820 2 : SgOmpRequiresStatement::extendMemoryPoolForFileIO( );
19821 2 : SgOmpTargetParallelStatement::extendMemoryPoolForFileIO( );
19822 2 : SgOmpTargetParallelForSimdStatement::extendMemoryPoolForFileIO( );
19823 2 : SgOmpTargetParallelLoopStatement::extendMemoryPoolForFileIO( );
19824 2 : SgOmpTargetSimdStatement::extendMemoryPoolForFileIO( );
19825 2 : SgOmpTargetTeamsStatement::extendMemoryPoolForFileIO( );
19826 2 : SgOmpTargetTeamsDistributeStatement::extendMemoryPoolForFileIO( );
19827 2 : SgOmpTargetTeamsDistributeSimdStatement::extendMemoryPoolForFileIO( );
19828 2 : SgOmpTargetTeamsLoopStatement::extendMemoryPoolForFileIO( );
19829 2 : SgOmpTargetTeamsDistributeParallelForStatement::extendMemoryPoolForFileIO( );
19830 2 : SgOmpTargetTeamsDistributeParallelForSimdStatement::extendMemoryPoolForFileIO( );
19831 2 : SgOmpDistributeSimdStatement::extendMemoryPoolForFileIO( );
19832 2 : SgOmpDistributeParallelForStatement::extendMemoryPoolForFileIO( );
19833 2 : SgOmpDistributeParallelForSimdStatement::extendMemoryPoolForFileIO( );
19834 2 : SgOmpTaskloopSimdStatement::extendMemoryPoolForFileIO( );
19835 2 : SgOmpMasterTaskloopSimdStatement::extendMemoryPoolForFileIO( );
19836 2 : SgOmpParallelMasterTaskloopStatement::extendMemoryPoolForFileIO( );
19837 2 : SgOmpParallelMasterTaskloopSimdStatement::extendMemoryPoolForFileIO( );
19838 2 : SgOmpTeamsDistributeStatement::extendMemoryPoolForFileIO( );
19839 2 : SgOmpTeamsDistributeSimdStatement::extendMemoryPoolForFileIO( );
19840 2 : SgOmpTeamsDistributeParallelForStatement::extendMemoryPoolForFileIO( );
19841 2 : SgOmpTeamsDistributeParallelForSimdStatement::extendMemoryPoolForFileIO( );
19842 2 : SgOmpTeamsLoopStatement::extendMemoryPoolForFileIO( );
19843 2 : SgOmpParallelLoopStatement::extendMemoryPoolForFileIO( );
19844 2 : SgOmpParallelMasterStatement::extendMemoryPoolForFileIO( );
19845 2 : SgOmpMasterTaskloopStatement::extendMemoryPoolForFileIO( );
19846 2 : SgOmpUnrollStatement::extendMemoryPoolForFileIO( );
19847 2 : SgOmpTileStatement::extendMemoryPoolForFileIO( );
19848 2 : SgUpirSimdStatement::extendMemoryPoolForFileIO( );
19849 2 : SgUpirBaseStatement::extendMemoryPoolForFileIO( );
19850 2 : SgUpirLoopStatement::extendMemoryPoolForFileIO( );
19851 2 : SgUpirLoopParallelStatement::extendMemoryPoolForFileIO( );
19852 2 : SgUpirSyncStatement::extendMemoryPoolForFileIO( );
19853 2 : SgOmpClause::extendMemoryPoolForFileIO( );
19854 2 : SgOmpAllocateClause::extendMemoryPoolForFileIO( );
19855 2 : SgOmpAllocatorClause::extendMemoryPoolForFileIO( );
19856 2 : SgOmpUsesAllocatorsClause::extendMemoryPoolForFileIO( );
19857 2 : SgOmpUsesAllocatorsDefination::extendMemoryPoolForFileIO( );
19858 2 : SgOmpToClause::extendMemoryPoolForFileIO( );
19859 2 : SgOmpFromClause::extendMemoryPoolForFileIO( );
19860 2 : SgOmpThreadsClause::extendMemoryPoolForFileIO( );
19861 2 : SgOmpSimdClause::extendMemoryPoolForFileIO( );
19862 2 : SgOmpBeginClause::extendMemoryPoolForFileIO( );
19863 2 : SgOmpCollapseClause::extendMemoryPoolForFileIO( );
19864 2 : SgOmpCopyinClause::extendMemoryPoolForFileIO( );
19865 2 : SgOmpCopyprivateClause::extendMemoryPoolForFileIO( );
19866 2 : SgOmpDefaultClause::extendMemoryPoolForFileIO( );
19867 2 : SgOmpEndClause::extendMemoryPoolForFileIO( );
19868 2 : SgOmpExpressionClause::extendMemoryPoolForFileIO( );
19869 2 : SgOmpFirstprivateClause::extendMemoryPoolForFileIO( );
19870 2 : SgOmpIfClause::extendMemoryPoolForFileIO( );
19871 2 : SgOmpFinalClause::extendMemoryPoolForFileIO( );
19872 2 : SgOmpPriorityClause::extendMemoryPoolForFileIO( );
19873 2 : SgOmpDeviceClause::extendMemoryPoolForFileIO( );
19874 2 : SgOmpLastprivateClause::extendMemoryPoolForFileIO( );
19875 2 : SgOmpNowaitClause::extendMemoryPoolForFileIO( );
19876 2 : SgOmpReadClause::extendMemoryPoolForFileIO( );
19877 2 : SgOmpWriteClause::extendMemoryPoolForFileIO( );
19878 2 : SgOmpUpdateClause::extendMemoryPoolForFileIO( );
19879 2 : SgOmpDepobjUpdateClause::extendMemoryPoolForFileIO( );
19880 2 : SgOmpDestroyClause::extendMemoryPoolForFileIO( );
19881 2 : SgOmpCaptureClause::extendMemoryPoolForFileIO( );
19882 2 : SgOmpSeqCstClause::extendMemoryPoolForFileIO( );
19883 2 : SgOmpAcqRelClause::extendMemoryPoolForFileIO( );
19884 2 : SgOmpReleaseClause::extendMemoryPoolForFileIO( );
19885 2 : SgOmpAcquireClause::extendMemoryPoolForFileIO( );
19886 2 : SgOmpReverseOffloadClause::extendMemoryPoolForFileIO( );
19887 2 : SgOmpUnifiedAddressClause::extendMemoryPoolForFileIO( );
19888 2 : SgOmpUnifiedSharedMemoryClause::extendMemoryPoolForFileIO( );
19889 2 : SgOmpDynamicAllocatorsClause::extendMemoryPoolForFileIO( );
19890 2 : SgOmpAtomicDefaultMemOrderClause::extendMemoryPoolForFileIO( );
19891 2 : SgOmpExtImplementationDefinedRequirementClause::extendMemoryPoolForFileIO( );
19892 2 : SgOmpRelaxedClause::extendMemoryPoolForFileIO( );
19893 2 : SgOmpParallelClause::extendMemoryPoolForFileIO( );
19894 2 : SgOmpSectionsClause::extendMemoryPoolForFileIO( );
19895 2 : SgOmpForClause::extendMemoryPoolForFileIO( );
19896 2 : SgOmpTaskgroupClause::extendMemoryPoolForFileIO( );
19897 2 : SgUpirNumUnitsField::extendMemoryPoolForFileIO( );
19898 2 : SgOmpNumTeamsClause::extendMemoryPoolForFileIO( );
19899 2 : SgOmpGrainsizeClause::extendMemoryPoolForFileIO( );
19900 2 : SgOmpDetachClause::extendMemoryPoolForFileIO( );
19901 2 : SgOmpNumTasksClause::extendMemoryPoolForFileIO( );
19902 2 : SgOmpNogroupClause::extendMemoryPoolForFileIO( );
19903 2 : SgOmpHintClause::extendMemoryPoolForFileIO( );
19904 2 : SgOmpOrderClause::extendMemoryPoolForFileIO( );
19905 2 : SgOmpDistScheduleClause::extendMemoryPoolForFileIO( );
19906 2 : SgOmpBindClause::extendMemoryPoolForFileIO( );
19907 2 : SgOmpNontemporalClause::extendMemoryPoolForFileIO( );
19908 2 : SgOmpInclusiveClause::extendMemoryPoolForFileIO( );
19909 2 : SgOmpExclusiveClause::extendMemoryPoolForFileIO( );
19910 2 : SgOmpIsDevicePtrClause::extendMemoryPoolForFileIO( );
19911 2 : SgOmpUseDevicePtrClause::extendMemoryPoolForFileIO( );
19912 2 : SgOmpUseDeviceAddrClause::extendMemoryPoolForFileIO( );
19913 2 : SgOmpThreadLimitClause::extendMemoryPoolForFileIO( );
19914 2 : SgOmpOrderedClause::extendMemoryPoolForFileIO( );
19915 2 : SgOmpPrivateClause::extendMemoryPoolForFileIO( );
19916 2 : SgOmpReductionClause::extendMemoryPoolForFileIO( );
19917 2 : SgOmpInReductionClause::extendMemoryPoolForFileIO( );
19918 2 : SgOmpTaskReductionClause::extendMemoryPoolForFileIO( );
19919 2 : SgOmpDefaultmapClause::extendMemoryPoolForFileIO( );
19920 2 : SgOmpScheduleClause::extendMemoryPoolForFileIO( );
19921 2 : SgOmpSharedClause::extendMemoryPoolForFileIO( );
19922 2 : SgOmpUntiedClause::extendMemoryPoolForFileIO( );
19923 2 : SgOmpMergeableClause::extendMemoryPoolForFileIO( );
19924 2 : SgOmpVariablesClause::extendMemoryPoolForFileIO( );
19925 2 : SgOmpMapClause::extendMemoryPoolForFileIO( );
19926 2 : SgOmpSafelenClause::extendMemoryPoolForFileIO( );
19927 2 : SgOmpSimdlenClause::extendMemoryPoolForFileIO( );
19928 2 : SgOmpLinearClause::extendMemoryPoolForFileIO( );
19929 2 : SgOmpUniformClause::extendMemoryPoolForFileIO( );
19930 2 : SgOmpAlignedClause::extendMemoryPoolForFileIO( );
19931 2 : SgOmpProcBindClause::extendMemoryPoolForFileIO( );
19932 2 : SgOmpAtomicClause::extendMemoryPoolForFileIO( );
19933 2 : SgOmpInbranchClause::extendMemoryPoolForFileIO( );
19934 2 : SgOmpNotinbranchClause::extendMemoryPoolForFileIO( );
19935 2 : SgOmpDependClause::extendMemoryPoolForFileIO( );
19936 2 : SgOmpAffinityClause::extendMemoryPoolForFileIO( );
19937 2 : SgOmpWhenClause::extendMemoryPoolForFileIO( );
19938 2 : SgOmpFullClause::extendMemoryPoolForFileIO( );
19939 2 : SgOmpPartialClause::extendMemoryPoolForFileIO( );
19940 2 : SgOmpSizesClause::extendMemoryPoolForFileIO( );
19941 2 : SgUpirBranchField::extendMemoryPoolForFileIO( );
19942 2 : SgUpirNestedLevelField::extendMemoryPoolForFileIO( );
19943 2 : SgUpirNestedParentField::extendMemoryPoolForFileIO( );
19944 2 : SgUpirNestedChildField::extendMemoryPoolForFileIO( );
19945 2 : SgUpirSyncField::extendMemoryPoolForFileIO( );
19946 2 : SgUpirDataField::extendMemoryPoolForFileIO( );
19947 2 : SgUpirDataItemField::extendMemoryPoolForFileIO( );
19948 2 : SgUpirTargetField::extendMemoryPoolForFileIO( );
19949 2 : SgOpenclAccessModeModifier::extendMemoryPoolForFileIO( );
19950 2 : SgOpenStatement::extendMemoryPoolForFileIO( );
19951 2 : SgOptions::extendMemoryPoolForFileIO( );
19952 2 : SgOrOp::extendMemoryPoolForFileIO( );
19953 2 : SgParameterStatement::extendMemoryPoolForFileIO( );
19954 2 : SgPartialFunctionModifierType::extendMemoryPoolForFileIO( );
19955 2 : SgPartialFunctionType::extendMemoryPoolForFileIO( );
19956 2 : SgPassStatement::extendMemoryPoolForFileIO( );
19957 2 : SgPlusAssignOp::extendMemoryPoolForFileIO( );
19958 2 : SgPlusPlusOp::extendMemoryPoolForFileIO( );
19959 2 : SgPntrArrRefExp::extendMemoryPoolForFileIO( );
19960 2 : SgPointerAssignOp::extendMemoryPoolForFileIO( );
19961 2 : SgPointerDerefExp::extendMemoryPoolForFileIO( );
19962 2 : SgPointerMemberType::extendMemoryPoolForFileIO( );
19963 2 : SgPointerType::extendMemoryPoolForFileIO( );
19964 2 : SgPowerOp::extendMemoryPoolForFileIO( );
19965 2 : SgPragma::extendMemoryPoolForFileIO( );
19966 2 : SgPragmaDeclaration::extendMemoryPoolForFileIO( );
19967 2 : SgPrintStatement::extendMemoryPoolForFileIO( );
19968 2 : SgProcedureHeaderStatement::extendMemoryPoolForFileIO( );
19969 2 : SgProgramHeaderStatement::extendMemoryPoolForFileIO( );
19970 2 : SgProject::extendMemoryPoolForFileIO( );
19971 2 : SgPseudoDestructorRefExp::extendMemoryPoolForFileIO( );
19972 2 : SgQualifiedName::extendMemoryPoolForFileIO( );
19973 2 : SgQualifiedNameType::extendMemoryPoolForFileIO( );
19974 2 : SgRangeExp::extendMemoryPoolForFileIO( );
19975 2 : SgRangeBasedForStatement::extendMemoryPoolForFileIO( );
19976 2 : SgReadStatement::extendMemoryPoolForFileIO( );
19977 2 : SgRealPartOp::extendMemoryPoolForFileIO( );
19978 2 : SgRefExp::extendMemoryPoolForFileIO( );
19979 2 : SgReferenceType::extendMemoryPoolForFileIO( );
19980 2 : SgRenamePair::extendMemoryPoolForFileIO( );
19981 2 : SgRenameSymbol::extendMemoryPoolForFileIO( );
19982 2 : SgReturnStmt::extendMemoryPoolForFileIO( );
19983 2 : SgRewindStatement::extendMemoryPoolForFileIO( );
19984 2 : SgRshiftAssignOp::extendMemoryPoolForFileIO( );
19985 2 : SgRshiftOp::extendMemoryPoolForFileIO( );
19986 2 : SgRvalueReferenceType::extendMemoryPoolForFileIO( );
19987 2 : SgScopeOp::extendMemoryPoolForFileIO( );
19988 2 : SgScopeStatement::extendMemoryPoolForFileIO( );
19989 2 : SgSequenceStatement::extendMemoryPoolForFileIO( );
19990 2 : SgSetComprehension::extendMemoryPoolForFileIO( );
19991 2 : SgShortVal::extendMemoryPoolForFileIO( );
19992 2 : SgSIMDBinaryOp::extendMemoryPoolForFileIO( );
19993 2 : SgSIMDAddOp::extendMemoryPoolForFileIO( );
19994 2 : SgSIMDSubOp::extendMemoryPoolForFileIO( );
19995 2 : SgSIMDMulOp::extendMemoryPoolForFileIO( );
19996 2 : SgSIMDDivOp::extendMemoryPoolForFileIO( );
19997 2 : SgSIMDFmaOp::extendMemoryPoolForFileIO( );
19998 2 : SgSIMDLoad::extendMemoryPoolForFileIO( );
19999 2 : SgSIMDBroadcast::extendMemoryPoolForFileIO( );
20000 2 : SgSIMDStore::extendMemoryPoolForFileIO( );
20001 2 : SgSIMDPartialStore::extendMemoryPoolForFileIO( );
20002 2 : SgSIMDScalarStore::extendMemoryPoolForFileIO( );
20003 2 : SgSIMDGather::extendMemoryPoolForFileIO( );
20004 2 : SgSIMDExplicitGather::extendMemoryPoolForFileIO( );
20005 2 : SgSIMDScatter::extendMemoryPoolForFileIO( );
20006 2 : SgSizeOfOp::extendMemoryPoolForFileIO( );
20007 2 : SgAlignOfOp::extendMemoryPoolForFileIO( );
20008 2 : SgSourceFile::extendMemoryPoolForFileIO( );
20009 2 : SgSpaceshipOp::extendMemoryPoolForFileIO( );
20010 2 : SgSpawnStmt::extendMemoryPoolForFileIO( );
20011 2 : SgSyncAllStatement::extendMemoryPoolForFileIO( );
20012 2 : SgSyncImagesStatement::extendMemoryPoolForFileIO( );
20013 2 : SgSyncMemoryStatement::extendMemoryPoolForFileIO( );
20014 2 : SgSyncTeamStatement::extendMemoryPoolForFileIO( );
20015 2 : SgLockStatement::extendMemoryPoolForFileIO( );
20016 2 : SgUnlockStatement::extendMemoryPoolForFileIO( );
20017 2 : SgProcessControlStatement::extendMemoryPoolForFileIO( );
20018 2 : SgSpecialFunctionModifier::extendMemoryPoolForFileIO( );
20019 2 : SgStatement::extendMemoryPoolForFileIO( );
20020 2 : SgStaticAssertionDeclaration::extendMemoryPoolForFileIO( );
20021 2 : SgStmtDeclarationStatement::extendMemoryPoolForFileIO( );
20022 2 : SgStatementExpression::extendMemoryPoolForFileIO( );
20023 2 : SgStatementFunctionStatement::extendMemoryPoolForFileIO( );
20024 2 : SgStorageModifier::extendMemoryPoolForFileIO( );
20025 2 : SgStringConversion::extendMemoryPoolForFileIO( );
20026 2 : SgStringKeyedBidirectionalGraph::extendMemoryPoolForFileIO( );
20027 2 : SgStringVal::extendMemoryPoolForFileIO( );
20028 2 : SgStructureModifier::extendMemoryPoolForFileIO( );
20029 2 : SgSubscriptExpression::extendMemoryPoolForFileIO( );
20030 2 : SgSubtractOp::extendMemoryPoolForFileIO( );
20031 2 : SgSupport::extendMemoryPoolForFileIO( );
20032 2 : SgSwitchStatement::extendMemoryPoolForFileIO( );
20033 2 : SgSymbol::extendMemoryPoolForFileIO( );
20034 2 : SgSymbolTable::extendMemoryPoolForFileIO( );
20035 2 : SgTemplateArgument::extendMemoryPoolForFileIO( );
20036 2 : SgTemplateArgumentList::extendMemoryPoolForFileIO( );
20037 2 : SgTemplateDeclaration::extendMemoryPoolForFileIO( );
20038 2 : SgTemplateClassDeclaration::extendMemoryPoolForFileIO( );
20039 2 : SgTemplateClassSymbol::extendMemoryPoolForFileIO( );
20040 2 : SgTemplateFunctionDeclaration::extendMemoryPoolForFileIO( );
20041 2 : SgTemplateFunctionRefExp::extendMemoryPoolForFileIO( );
20042 2 : SgTemplateFunctionSymbol::extendMemoryPoolForFileIO( );
20043 2 : SgTemplateMemberFunctionDeclaration::extendMemoryPoolForFileIO( );
20044 2 : SgTemplateMemberFunctionRefExp::extendMemoryPoolForFileIO( );
20045 2 : SgTemplateMemberFunctionSymbol::extendMemoryPoolForFileIO( );
20046 2 : SgTemplateTypedefDeclaration::extendMemoryPoolForFileIO( );
20047 2 : SgTemplateTypedefSymbol::extendMemoryPoolForFileIO( );
20048 2 : SgTemplateVariableDeclaration::extendMemoryPoolForFileIO( );
20049 2 : SgTemplateVariableSymbol::extendMemoryPoolForFileIO( );
20050 2 : SgTemplateClassDefinition::extendMemoryPoolForFileIO( );
20051 2 : SgTemplateFunctionDefinition::extendMemoryPoolForFileIO( );
20052 2 : SgTemplateInstantiationDecl::extendMemoryPoolForFileIO( );
20053 2 : SgTemplateInstantiationDefn::extendMemoryPoolForFileIO( );
20054 2 : SgTemplateInstantiationDirectiveStatement::extendMemoryPoolForFileIO( );
20055 2 : SgTemplateInstantiationFunctionDecl::extendMemoryPoolForFileIO( );
20056 2 : SgTemplateInstantiationMemberFunctionDecl::extendMemoryPoolForFileIO( );
20057 2 : SgTemplateInstantiationTypedefDeclaration::extendMemoryPoolForFileIO( );
20058 2 : SgTemplateParameter::extendMemoryPoolForFileIO( );
20059 2 : SgTemplateParameterVal::extendMemoryPoolForFileIO( );
20060 2 : SgTemplateParameterList::extendMemoryPoolForFileIO( );
20061 2 : SgTemplateSymbol::extendMemoryPoolForFileIO( );
20062 2 : SgTemplateType::extendMemoryPoolForFileIO( );
20063 2 : SgThisExp::extendMemoryPoolForFileIO( );
20064 2 : SgTypeTraitBuiltinOperator::extendMemoryPoolForFileIO( );
20065 2 : SgSuperExp::extendMemoryPoolForFileIO( );
20066 2 : SgThrowOp::extendMemoryPoolForFileIO( );
20067 2 : SgToken::extendMemoryPoolForFileIO( );
20068 2 : SgTryStmt::extendMemoryPoolForFileIO( );
20069 2 : SgTupleExp::extendMemoryPoolForFileIO( );
20070 2 : SgType::extendMemoryPoolForFileIO( );
20071 2 : SgTypeBool::extendMemoryPoolForFileIO( );
20072 2 : SgTypeChar::extendMemoryPoolForFileIO( );
20073 2 : SgTypeChar16::extendMemoryPoolForFileIO( );
20074 2 : SgTypeChar32::extendMemoryPoolForFileIO( );
20075 2 : SgTypeComplex::extendMemoryPoolForFileIO( );
20076 2 : SgTypeDefault::extendMemoryPoolForFileIO( );
20077 2 : SgTypeExpression::extendMemoryPoolForFileIO( );
20078 2 : SgTypeLabel::extendMemoryPoolForFileIO( );
20079 2 : SgTypeDouble::extendMemoryPoolForFileIO( );
20080 2 : SgTypeEllipse::extendMemoryPoolForFileIO( );
20081 2 : SgTypeFixed::extendMemoryPoolForFileIO( );
20082 2 : SgTypeFloat::extendMemoryPoolForFileIO( );
20083 2 : SgTypeFloat128::extendMemoryPoolForFileIO( );
20084 2 : SgTypeFloat80::extendMemoryPoolForFileIO( );
20085 2 : SgTypeGlobalVoid::extendMemoryPoolForFileIO( );
20086 2 : SgTypeIdOp::extendMemoryPoolForFileIO( );
20087 2 : SgTypeImaginary::extendMemoryPoolForFileIO( );
20088 2 : SgTypeInt::extendMemoryPoolForFileIO( );
20089 2 : SgTypeLong::extendMemoryPoolForFileIO( );
20090 2 : SgTypeLongDouble::extendMemoryPoolForFileIO( );
20091 2 : SgTypeLongLong::extendMemoryPoolForFileIO( );
20092 2 : SgTypeModifier::extendMemoryPoolForFileIO( );
20093 2 : SgTypeMatrix::extendMemoryPoolForFileIO( );
20094 2 : SgTypeTuple::extendMemoryPoolForFileIO( );
20095 2 : SgTypeNullptr::extendMemoryPoolForFileIO( );
20096 2 : SgTypeOfType::extendMemoryPoolForFileIO( );
20097 2 : SgTypeShort::extendMemoryPoolForFileIO( );
20098 2 : SgTypeSigned128bitInteger::extendMemoryPoolForFileIO( );
20099 2 : SgTypeSignedChar::extendMemoryPoolForFileIO( );
20100 2 : SgTypeSignedInt::extendMemoryPoolForFileIO( );
20101 2 : SgTypeSignedLong::extendMemoryPoolForFileIO( );
20102 2 : SgTypeSignedLongLong::extendMemoryPoolForFileIO( );
20103 2 : SgTypeSignedShort::extendMemoryPoolForFileIO( );
20104 2 : SgTypeString::extendMemoryPoolForFileIO( );
20105 2 : SgTypeUnknown::extendMemoryPoolForFileIO( );
20106 2 : SgTypeUnsigned128bitInteger::extendMemoryPoolForFileIO( );
20107 2 : SgTypeUnsignedChar::extendMemoryPoolForFileIO( );
20108 2 : SgTypeUnsignedInt::extendMemoryPoolForFileIO( );
20109 2 : SgTypeUnsignedLong::extendMemoryPoolForFileIO( );
20110 2 : SgTypeUnsignedLongLong::extendMemoryPoolForFileIO( );
20111 2 : SgTypeUnsignedShort::extendMemoryPoolForFileIO( );
20112 2 : SgTypeVoid::extendMemoryPoolForFileIO( );
20113 2 : SgTypeWchar::extendMemoryPoolForFileIO( );
20114 2 : SgTypedefDeclaration::extendMemoryPoolForFileIO( );
20115 2 : SgTypedefSeq::extendMemoryPoolForFileIO( );
20116 2 : SgTypedefSymbol::extendMemoryPoolForFileIO( );
20117 2 : SgTypedefType::extendMemoryPoolForFileIO( );
20118 2 : SgUPC_AccessModifier::extendMemoryPoolForFileIO( );
20119 2 : SgUnaryAddOp::extendMemoryPoolForFileIO( );
20120 2 : SgUnaryOp::extendMemoryPoolForFileIO( );
20121 2 : SgUndefDirectiveStatement::extendMemoryPoolForFileIO( );
20122 2 : SgUndirectedGraphEdge::extendMemoryPoolForFileIO( );
20123 2 : SgUnknownArrayOrFunctionReference::extendMemoryPoolForFileIO( );
20124 2 : SgUnknownFile::extendMemoryPoolForFileIO( );
20125 2 : SgUnparse_Info::extendMemoryPoolForFileIO( );
20126 2 : SgUnsignedCharVal::extendMemoryPoolForFileIO( );
20127 2 : SgUnsignedIntVal::extendMemoryPoolForFileIO( );
20128 2 : SgUnsignedLongLongIntVal::extendMemoryPoolForFileIO( );
20129 2 : SgUnsignedLongVal::extendMemoryPoolForFileIO( );
20130 2 : SgUnsignedShortVal::extendMemoryPoolForFileIO( );
20131 2 : SgUpcBarrierStatement::extendMemoryPoolForFileIO( );
20132 2 : SgUpcBlocksizeofExpression::extendMemoryPoolForFileIO( );
20133 2 : SgUpcElemsizeofExpression::extendMemoryPoolForFileIO( );
20134 2 : SgUpcFenceStatement::extendMemoryPoolForFileIO( );
20135 2 : SgUpcForAllStatement::extendMemoryPoolForFileIO( );
20136 2 : SgUpcLocalsizeofExpression::extendMemoryPoolForFileIO( );
20137 2 : SgUpcMythread::extendMemoryPoolForFileIO( );
20138 2 : SgUpcNotifyStatement::extendMemoryPoolForFileIO( );
20139 2 : SgUpcThreads::extendMemoryPoolForFileIO( );
20140 2 : SgUpcWaitStatement::extendMemoryPoolForFileIO( );
20141 2 : SgUseStatement::extendMemoryPoolForFileIO( );
20142 2 : SgUserDefinedBinaryOp::extendMemoryPoolForFileIO( );
20143 2 : SgUserDefinedUnaryOp::extendMemoryPoolForFileIO( );
20144 2 : SgUsingDeclarationStatement::extendMemoryPoolForFileIO( );
20145 2 : SgUsingDirectiveStatement::extendMemoryPoolForFileIO( );
20146 2 : SgValueExp::extendMemoryPoolForFileIO( );
20147 2 : SgVarArgCopyOp::extendMemoryPoolForFileIO( );
20148 2 : SgVarArgEndOp::extendMemoryPoolForFileIO( );
20149 2 : SgVarArgOp::extendMemoryPoolForFileIO( );
20150 2 : SgVarArgStartOneOperandOp::extendMemoryPoolForFileIO( );
20151 2 : SgVarArgStartOp::extendMemoryPoolForFileIO( );
20152 2 : SgVarRefExp::extendMemoryPoolForFileIO( );
20153 2 : SgVariableDeclaration::extendMemoryPoolForFileIO( );
20154 2 : SgVariableDefinition::extendMemoryPoolForFileIO( );
20155 2 : SgVariableSymbol::extendMemoryPoolForFileIO( );
20156 2 : SgVariantExpression::extendMemoryPoolForFileIO( );
20157 2 : SgVariantStatement::extendMemoryPoolForFileIO( );
20158 2 : SgVoidVal::extendMemoryPoolForFileIO( );
20159 2 : SgWaitStatement::extendMemoryPoolForFileIO( );
20160 2 : SgWarningDirectiveStatement::extendMemoryPoolForFileIO( );
20161 2 : SgWithStatement::extendMemoryPoolForFileIO( );
20162 2 : SgWcharVal::extendMemoryPoolForFileIO( );
20163 2 : SgWhereStatement::extendMemoryPoolForFileIO( );
20164 2 : SgWhileStmt::extendMemoryPoolForFileIO( );
20165 2 : SgWriteStatement::extendMemoryPoolForFileIO( );
20166 2 : SgXorAssignOp::extendMemoryPoolForFileIO( );
20167 2 : SgYieldExpression::extendMemoryPoolForFileIO( );
20168 2 : Sg_File_Info::extendMemoryPoolForFileIO( );
20169 2 : SgTypeCAFTeam::extendMemoryPoolForFileIO( );
20170 2 : SgCAFWithTeamStatement::extendMemoryPoolForFileIO( );
20171 2 : SgCAFCoExpression::extendMemoryPoolForFileIO( );
20172 2 : SgCallExpression::extendMemoryPoolForFileIO( );
20173 2 : SgTypeCrayPointer::extendMemoryPoolForFileIO( );
20174 2 : SgClassExp::extendMemoryPoolForFileIO( );
20175 :
20176 : /* #line 400 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
20177 :
20178 2 : return;
20179 : }
20180 :
20181 :
20182 : int
20183 7 : AST_FILE_IO::getNumberOfAsts ()
20184 : {
20185 7 : return vectorOfASTs.size();
20186 : }
20187 :
20188 :
20189 : void
20190 2 : AST_FILE_IO::addNewAst (AstData* newAst)
20191 : {
20192 2 : vectorOfASTs.push_back(newAst);
20193 2 : actualRebuildAst = newAst;
20194 2 : return;
20195 : }
20196 :
20197 :
20198 : void
20199 0 : AST_FILE_IO::printFileMaps ()
20200 : {
20201 0 : std::map<int,std::string> :: iterator Iter1 = Sg_File_Info::p_fileidtoname_map.begin();
20202 0 : for ( ; Iter1 != Sg_File_Info::p_fileidtoname_map.end(); ++Iter1)
20203 : {
20204 0 : std::cout << Iter1->first << " " << Iter1->second << std::endl;
20205 : }
20206 0 : std::map<std::string,int> :: iterator Iter2 = Sg_File_Info::p_nametofileid_map.begin();
20207 0 : for ( ; Iter2 != Sg_File_Info::p_nametofileid_map.end(); ++Iter2)
20208 : {
20209 0 : std::cout << Iter2->first << " " << Iter2->second << std::endl;
20210 : }
20211 0 : }
20212 :
20213 :
20214 :
20215 : void
20216 0 : AST_FILE_IO::deleteStoredAsts ()
20217 : {
20218 0 : std::vector<AstData*>::iterator astIterator = vectorOfASTs.begin();
20219 0 : for ( ; astIterator != vectorOfASTs.end(); ++astIterator)
20220 : {
20221 0 : delete (*astIterator);
20222 : }
20223 0 : vectorOfASTs.clear();
20224 0 : return;
20225 : }
20226 :
20227 :
20228 :
20229 : void
20230 2 : AST_FILE_IO::setStaticDataOfAst (AstData *astInPool)
20231 : {
20232 2 : assert (astInPool->get_AstIndex() < (int)vectorOfASTs.size());
20233 2 : astInPool->setStaticDataMembersOfIRNodes();
20234 2 : return;
20235 : }
20236 :
20237 :
20238 :
20239 :
20240 : void
20241 0 : AST_FILE_IO::printListOfPoolSizes ()
20242 : {
20243 0 : std::cout << "Memory pool size of SgAccessModifier: " << listOfMemoryPoolSizes[V_SgAccessModifier] << std::endl;
20244 0 : std::cout << "Memory pool size of SgActualArgumentExpression: " << listOfMemoryPoolSizes[V_SgActualArgumentExpression] << std::endl;
20245 0 : std::cout << "Memory pool size of SgAddOp: " << listOfMemoryPoolSizes[V_SgAddOp] << std::endl;
20246 0 : std::cout << "Memory pool size of SgAddressOfOp: " << listOfMemoryPoolSizes[V_SgAddressOfOp] << std::endl;
20247 0 : std::cout << "Memory pool size of SgAggregateInitializer: " << listOfMemoryPoolSizes[V_SgAggregateInitializer] << std::endl;
20248 0 : std::cout << "Memory pool size of SgAliasSymbol: " << listOfMemoryPoolSizes[V_SgAliasSymbol] << std::endl;
20249 0 : std::cout << "Memory pool size of SgAllocateStatement: " << listOfMemoryPoolSizes[V_SgAllocateStatement] << std::endl;
20250 0 : std::cout << "Memory pool size of SgAndAssignOp: " << listOfMemoryPoolSizes[V_SgAndAssignOp] << std::endl;
20251 0 : std::cout << "Memory pool size of SgAndOp: " << listOfMemoryPoolSizes[V_SgAndOp] << std::endl;
20252 0 : std::cout << "Memory pool size of SgArithmeticIfStatement: " << listOfMemoryPoolSizes[V_SgArithmeticIfStatement] << std::endl;
20253 0 : std::cout << "Memory pool size of SgArrayType: " << listOfMemoryPoolSizes[V_SgArrayType] << std::endl;
20254 0 : std::cout << "Memory pool size of SgArrowExp: " << listOfMemoryPoolSizes[V_SgArrowExp] << std::endl;
20255 0 : std::cout << "Memory pool size of SgArrowStarOp: " << listOfMemoryPoolSizes[V_SgArrowStarOp] << std::endl;
20256 0 : std::cout << "Memory pool size of SgAsmOp: " << listOfMemoryPoolSizes[V_SgAsmOp] << std::endl;
20257 0 : std::cout << "Memory pool size of SgAsmStmt: " << listOfMemoryPoolSizes[V_SgAsmStmt] << std::endl;
20258 0 : std::cout << "Memory pool size of SgAssertStmt: " << listOfMemoryPoolSizes[V_SgAssertStmt] << std::endl;
20259 0 : std::cout << "Memory pool size of SgAssignInitializer: " << listOfMemoryPoolSizes[V_SgAssignInitializer] << std::endl;
20260 0 : std::cout << "Memory pool size of SgAssignOp: " << listOfMemoryPoolSizes[V_SgAssignOp] << std::endl;
20261 0 : std::cout << "Memory pool size of SgAssignStatement: " << listOfMemoryPoolSizes[V_SgAssignStatement] << std::endl;
20262 0 : std::cout << "Memory pool size of SgAssignedGotoStatement: " << listOfMemoryPoolSizes[V_SgAssignedGotoStatement] << std::endl;
20263 0 : std::cout << "Memory pool size of SgAssociateStatement: " << listOfMemoryPoolSizes[V_SgAssociateStatement] << std::endl;
20264 0 : std::cout << "Memory pool size of SgAsteriskShapeExp: " << listOfMemoryPoolSizes[V_SgAsteriskShapeExp] << std::endl;
20265 0 : std::cout << "Memory pool size of SgAttribute: " << listOfMemoryPoolSizes[V_SgAttribute] << std::endl;
20266 0 : std::cout << "Memory pool size of SgAttributeSpecificationStatement: " << listOfMemoryPoolSizes[V_SgAttributeSpecificationStatement] << std::endl;
20267 0 : std::cout << "Memory pool size of SgAutoType: " << listOfMemoryPoolSizes[V_SgAutoType] << std::endl;
20268 0 : std::cout << "Memory pool size of SgAwaitExpression: " << listOfMemoryPoolSizes[V_SgAwaitExpression] << std::endl;
20269 0 : std::cout << "Memory pool size of SgBackspaceStatement: " << listOfMemoryPoolSizes[V_SgBackspaceStatement] << std::endl;
20270 0 : std::cout << "Memory pool size of SgBaseClass: " << listOfMemoryPoolSizes[V_SgBaseClass] << std::endl;
20271 0 : std::cout << "Memory pool size of SgExpBaseClass: " << listOfMemoryPoolSizes[V_SgExpBaseClass] << std::endl;
20272 0 : std::cout << "Memory pool size of SgBaseClassModifier: " << listOfMemoryPoolSizes[V_SgBaseClassModifier] << std::endl;
20273 0 : std::cout << "Memory pool size of SgBasicBlock: " << listOfMemoryPoolSizes[V_SgBasicBlock] << std::endl;
20274 0 : std::cout << "Memory pool size of SgBidirectionalGraph: " << listOfMemoryPoolSizes[V_SgBidirectionalGraph] << std::endl;
20275 0 : std::cout << "Memory pool size of SgBinaryOp: " << listOfMemoryPoolSizes[V_SgBinaryOp] << std::endl;
20276 0 : std::cout << "Memory pool size of SgBitAndOp: " << listOfMemoryPoolSizes[V_SgBitAndOp] << std::endl;
20277 0 : std::cout << "Memory pool size of SgBitAttribute: " << listOfMemoryPoolSizes[V_SgBitAttribute] << std::endl;
20278 0 : std::cout << "Memory pool size of SgBitComplementOp: " << listOfMemoryPoolSizes[V_SgBitComplementOp] << std::endl;
20279 0 : std::cout << "Memory pool size of SgBitEqvOp: " << listOfMemoryPoolSizes[V_SgBitEqvOp] << std::endl;
20280 0 : std::cout << "Memory pool size of SgBitOrOp: " << listOfMemoryPoolSizes[V_SgBitOrOp] << std::endl;
20281 0 : std::cout << "Memory pool size of SgBitXorOp: " << listOfMemoryPoolSizes[V_SgBitXorOp] << std::endl;
20282 0 : std::cout << "Memory pool size of SgBlockDataStatement: " << listOfMemoryPoolSizes[V_SgBlockDataStatement] << std::endl;
20283 0 : std::cout << "Memory pool size of SgBoolValExp: " << listOfMemoryPoolSizes[V_SgBoolValExp] << std::endl;
20284 0 : std::cout << "Memory pool size of SgBreakStmt: " << listOfMemoryPoolSizes[V_SgBreakStmt] << std::endl;
20285 0 : std::cout << "Memory pool size of SgBracedInitializer: " << listOfMemoryPoolSizes[V_SgBracedInitializer] << std::endl;
20286 0 : std::cout << "Memory pool size of SgC_PreprocessorDirectiveStatement: " << listOfMemoryPoolSizes[V_SgC_PreprocessorDirectiveStatement] << std::endl;
20287 0 : std::cout << "Memory pool size of SgCaseOptionStmt: " << listOfMemoryPoolSizes[V_SgCaseOptionStmt] << std::endl;
20288 0 : std::cout << "Memory pool size of SgCastExp: " << listOfMemoryPoolSizes[V_SgCastExp] << std::endl;
20289 0 : std::cout << "Memory pool size of SgCatchOptionStmt: " << listOfMemoryPoolSizes[V_SgCatchOptionStmt] << std::endl;
20290 0 : std::cout << "Memory pool size of SgCatchStatementSeq: " << listOfMemoryPoolSizes[V_SgCatchStatementSeq] << std::endl;
20291 0 : std::cout << "Memory pool size of SgCharVal: " << listOfMemoryPoolSizes[V_SgCharVal] << std::endl;
20292 0 : std::cout << "Memory pool size of SgChar16Val: " << listOfMemoryPoolSizes[V_SgChar16Val] << std::endl;
20293 0 : std::cout << "Memory pool size of SgChar32Val: " << listOfMemoryPoolSizes[V_SgChar32Val] << std::endl;
20294 0 : std::cout << "Memory pool size of SgChooseExpression: " << listOfMemoryPoolSizes[V_SgChooseExpression] << std::endl;
20295 0 : std::cout << "Memory pool size of SgClassDecl_attr: " << listOfMemoryPoolSizes[V_SgClassDecl_attr] << std::endl;
20296 0 : std::cout << "Memory pool size of SgClassDeclaration: " << listOfMemoryPoolSizes[V_SgClassDeclaration] << std::endl;
20297 0 : std::cout << "Memory pool size of SgClassDefinition: " << listOfMemoryPoolSizes[V_SgClassDefinition] << std::endl;
20298 0 : std::cout << "Memory pool size of SgClassNameRefExp: " << listOfMemoryPoolSizes[V_SgClassNameRefExp] << std::endl;
20299 0 : std::cout << "Memory pool size of SgClassSymbol: " << listOfMemoryPoolSizes[V_SgClassSymbol] << std::endl;
20300 0 : std::cout << "Memory pool size of SgClassType: " << listOfMemoryPoolSizes[V_SgClassType] << std::endl;
20301 0 : std::cout << "Memory pool size of SgClinkageDeclarationStatement: " << listOfMemoryPoolSizes[V_SgClinkageDeclarationStatement] << std::endl;
20302 0 : std::cout << "Memory pool size of SgClinkageEndStatement: " << listOfMemoryPoolSizes[V_SgClinkageEndStatement] << std::endl;
20303 0 : std::cout << "Memory pool size of SgClinkageStartStatement: " << listOfMemoryPoolSizes[V_SgClinkageStartStatement] << std::endl;
20304 0 : std::cout << "Memory pool size of SgCloseStatement: " << listOfMemoryPoolSizes[V_SgCloseStatement] << std::endl;
20305 0 : std::cout << "Memory pool size of SgColonShapeExp: " << listOfMemoryPoolSizes[V_SgColonShapeExp] << std::endl;
20306 0 : std::cout << "Memory pool size of SgCommaOpExp: " << listOfMemoryPoolSizes[V_SgCommaOpExp] << std::endl;
20307 0 : std::cout << "Memory pool size of SgCommonBlock: " << listOfMemoryPoolSizes[V_SgCommonBlock] << std::endl;
20308 0 : std::cout << "Memory pool size of SgCommonBlockObject: " << listOfMemoryPoolSizes[V_SgCommonBlockObject] << std::endl;
20309 0 : std::cout << "Memory pool size of SgCommonSymbol: " << listOfMemoryPoolSizes[V_SgCommonSymbol] << std::endl;
20310 0 : std::cout << "Memory pool size of SgComplexVal: " << listOfMemoryPoolSizes[V_SgComplexVal] << std::endl;
20311 0 : std::cout << "Memory pool size of SgComprehension: " << listOfMemoryPoolSizes[V_SgComprehension] << std::endl;
20312 0 : std::cout << "Memory pool size of SgCompoundAssignOp: " << listOfMemoryPoolSizes[V_SgCompoundAssignOp] << std::endl;
20313 0 : std::cout << "Memory pool size of SgCompoundInitializer: " << listOfMemoryPoolSizes[V_SgCompoundInitializer] << std::endl;
20314 0 : std::cout << "Memory pool size of SgCompoundLiteralExp: " << listOfMemoryPoolSizes[V_SgCompoundLiteralExp] << std::endl;
20315 0 : std::cout << "Memory pool size of SgComputedGotoStatement: " << listOfMemoryPoolSizes[V_SgComputedGotoStatement] << std::endl;
20316 0 : std::cout << "Memory pool size of SgConcatenationOp: " << listOfMemoryPoolSizes[V_SgConcatenationOp] << std::endl;
20317 0 : std::cout << "Memory pool size of SgConditionalExp: " << listOfMemoryPoolSizes[V_SgConditionalExp] << std::endl;
20318 0 : std::cout << "Memory pool size of SgConjugateOp: " << listOfMemoryPoolSizes[V_SgConjugateOp] << std::endl;
20319 0 : std::cout << "Memory pool size of SgConstVolatileModifier: " << listOfMemoryPoolSizes[V_SgConstVolatileModifier] << std::endl;
20320 0 : std::cout << "Memory pool size of SgConstructorInitializer: " << listOfMemoryPoolSizes[V_SgConstructorInitializer] << std::endl;
20321 0 : std::cout << "Memory pool size of SgContainsStatement: " << listOfMemoryPoolSizes[V_SgContainsStatement] << std::endl;
20322 0 : std::cout << "Memory pool size of SgContinueStmt: " << listOfMemoryPoolSizes[V_SgContinueStmt] << std::endl;
20323 0 : std::cout << "Memory pool size of SgCtorInitializerList: " << listOfMemoryPoolSizes[V_SgCtorInitializerList] << std::endl;
20324 0 : std::cout << "Memory pool size of SgDataStatementGroup: " << listOfMemoryPoolSizes[V_SgDataStatementGroup] << std::endl;
20325 0 : std::cout << "Memory pool size of SgDataStatementObject: " << listOfMemoryPoolSizes[V_SgDataStatementObject] << std::endl;
20326 0 : std::cout << "Memory pool size of SgDataStatementValue: " << listOfMemoryPoolSizes[V_SgDataStatementValue] << std::endl;
20327 0 : std::cout << "Memory pool size of SgDeadIfDirectiveStatement: " << listOfMemoryPoolSizes[V_SgDeadIfDirectiveStatement] << std::endl;
20328 0 : std::cout << "Memory pool size of SgDeallocateStatement: " << listOfMemoryPoolSizes[V_SgDeallocateStatement] << std::endl;
20329 0 : std::cout << "Memory pool size of SgDeclarationModifier: " << listOfMemoryPoolSizes[V_SgDeclarationModifier] << std::endl;
20330 0 : std::cout << "Memory pool size of SgDeclarationScope: " << listOfMemoryPoolSizes[V_SgDeclarationScope] << std::endl;
20331 0 : std::cout << "Memory pool size of SgDeclarationStatement: " << listOfMemoryPoolSizes[V_SgDeclarationStatement] << std::endl;
20332 0 : std::cout << "Memory pool size of SgDeclType: " << listOfMemoryPoolSizes[V_SgDeclType] << std::endl;
20333 0 : std::cout << "Memory pool size of SgDefaultOptionStmt: " << listOfMemoryPoolSizes[V_SgDefaultOptionStmt] << std::endl;
20334 0 : std::cout << "Memory pool size of SgDefaultSymbol: " << listOfMemoryPoolSizes[V_SgDefaultSymbol] << std::endl;
20335 0 : std::cout << "Memory pool size of SgDefineDirectiveStatement: " << listOfMemoryPoolSizes[V_SgDefineDirectiveStatement] << std::endl;
20336 0 : std::cout << "Memory pool size of SgDeleteExp: " << listOfMemoryPoolSizes[V_SgDeleteExp] << std::endl;
20337 0 : std::cout << "Memory pool size of SgDerivedTypeStatement: " << listOfMemoryPoolSizes[V_SgDerivedTypeStatement] << std::endl;
20338 0 : std::cout << "Memory pool size of SgDesignatedInitializer: " << listOfMemoryPoolSizes[V_SgDesignatedInitializer] << std::endl;
20339 0 : std::cout << "Memory pool size of SgDictionaryComprehension: " << listOfMemoryPoolSizes[V_SgDictionaryComprehension] << std::endl;
20340 0 : std::cout << "Memory pool size of SgDictionaryExp: " << listOfMemoryPoolSizes[V_SgDictionaryExp] << std::endl;
20341 0 : std::cout << "Memory pool size of SgDimensionObject: " << listOfMemoryPoolSizes[V_SgDimensionObject] << std::endl;
20342 0 : std::cout << "Memory pool size of SgDirectedGraphEdge: " << listOfMemoryPoolSizes[V_SgDirectedGraphEdge] << std::endl;
20343 0 : std::cout << "Memory pool size of SgDirectory: " << listOfMemoryPoolSizes[V_SgDirectory] << std::endl;
20344 0 : std::cout << "Memory pool size of SgDirectoryList: " << listOfMemoryPoolSizes[V_SgDirectoryList] << std::endl;
20345 0 : std::cout << "Memory pool size of SgDivAssignOp: " << listOfMemoryPoolSizes[V_SgDivAssignOp] << std::endl;
20346 0 : std::cout << "Memory pool size of SgDivideOp: " << listOfMemoryPoolSizes[V_SgDivideOp] << std::endl;
20347 0 : std::cout << "Memory pool size of SgDoWhileStmt: " << listOfMemoryPoolSizes[V_SgDoWhileStmt] << std::endl;
20348 0 : std::cout << "Memory pool size of SgDotExp: " << listOfMemoryPoolSizes[V_SgDotExp] << std::endl;
20349 0 : std::cout << "Memory pool size of SgDotStarOp: " << listOfMemoryPoolSizes[V_SgDotStarOp] << std::endl;
20350 0 : std::cout << "Memory pool size of SgDoubleVal: " << listOfMemoryPoolSizes[V_SgDoubleVal] << std::endl;
20351 0 : std::cout << "Memory pool size of SgElaboratedTypeModifier: " << listOfMemoryPoolSizes[V_SgElaboratedTypeModifier] << std::endl;
20352 0 : std::cout << "Memory pool size of SgElementwiseOp: " << listOfMemoryPoolSizes[V_SgElementwiseOp] << std::endl;
20353 0 : std::cout << "Memory pool size of SgElementwiseAddOp: " << listOfMemoryPoolSizes[V_SgElementwiseAddOp] << std::endl;
20354 0 : std::cout << "Memory pool size of SgElementwiseDivideOp: " << listOfMemoryPoolSizes[V_SgElementwiseDivideOp] << std::endl;
20355 0 : std::cout << "Memory pool size of SgElementwiseLeftDivideOp: " << listOfMemoryPoolSizes[V_SgElementwiseLeftDivideOp] << std::endl;
20356 0 : std::cout << "Memory pool size of SgElementwiseMultiplyOp: " << listOfMemoryPoolSizes[V_SgElementwiseMultiplyOp] << std::endl;
20357 0 : std::cout << "Memory pool size of SgElementwisePowerOp: " << listOfMemoryPoolSizes[V_SgElementwisePowerOp] << std::endl;
20358 0 : std::cout << "Memory pool size of SgElementwiseSubtractOp: " << listOfMemoryPoolSizes[V_SgElementwiseSubtractOp] << std::endl;
20359 0 : std::cout << "Memory pool size of SgElseDirectiveStatement: " << listOfMemoryPoolSizes[V_SgElseDirectiveStatement] << std::endl;
20360 0 : std::cout << "Memory pool size of SgElseWhereStatement: " << listOfMemoryPoolSizes[V_SgElseWhereStatement] << std::endl;
20361 0 : std::cout << "Memory pool size of SgElseifDirectiveStatement: " << listOfMemoryPoolSizes[V_SgElseifDirectiveStatement] << std::endl;
20362 0 : std::cout << "Memory pool size of SgEmptyDeclaration: " << listOfMemoryPoolSizes[V_SgEmptyDeclaration] << std::endl;
20363 0 : std::cout << "Memory pool size of SgEmptyDirectiveStatement: " << listOfMemoryPoolSizes[V_SgEmptyDirectiveStatement] << std::endl;
20364 0 : std::cout << "Memory pool size of SgEndfileStatement: " << listOfMemoryPoolSizes[V_SgEndfileStatement] << std::endl;
20365 0 : std::cout << "Memory pool size of SgEndifDirectiveStatement: " << listOfMemoryPoolSizes[V_SgEndifDirectiveStatement] << std::endl;
20366 0 : std::cout << "Memory pool size of SgEntryStatement: " << listOfMemoryPoolSizes[V_SgEntryStatement] << std::endl;
20367 0 : std::cout << "Memory pool size of SgEnumDeclaration: " << listOfMemoryPoolSizes[V_SgEnumDeclaration] << std::endl;
20368 0 : std::cout << "Memory pool size of SgEnumFieldSymbol: " << listOfMemoryPoolSizes[V_SgEnumFieldSymbol] << std::endl;
20369 0 : std::cout << "Memory pool size of SgEnumSymbol: " << listOfMemoryPoolSizes[V_SgEnumSymbol] << std::endl;
20370 0 : std::cout << "Memory pool size of SgEnumType: " << listOfMemoryPoolSizes[V_SgEnumType] << std::endl;
20371 0 : std::cout << "Memory pool size of SgEnumVal: " << listOfMemoryPoolSizes[V_SgEnumVal] << std::endl;
20372 0 : std::cout << "Memory pool size of SgEqualityOp: " << listOfMemoryPoolSizes[V_SgEqualityOp] << std::endl;
20373 0 : std::cout << "Memory pool size of SgEquivalenceStatement: " << listOfMemoryPoolSizes[V_SgEquivalenceStatement] << std::endl;
20374 0 : std::cout << "Memory pool size of SgErrorDirectiveStatement: " << listOfMemoryPoolSizes[V_SgErrorDirectiveStatement] << std::endl;
20375 0 : std::cout << "Memory pool size of SgExecStatement: " << listOfMemoryPoolSizes[V_SgExecStatement] << std::endl;
20376 0 : std::cout << "Memory pool size of SgExponentiationOp: " << listOfMemoryPoolSizes[V_SgExponentiationOp] << std::endl;
20377 0 : std::cout << "Memory pool size of SgExponentiationAssignOp: " << listOfMemoryPoolSizes[V_SgExponentiationAssignOp] << std::endl;
20378 0 : std::cout << "Memory pool size of SgExprListExp: " << listOfMemoryPoolSizes[V_SgExprListExp] << std::endl;
20379 0 : std::cout << "Memory pool size of SgExprStatement: " << listOfMemoryPoolSizes[V_SgExprStatement] << std::endl;
20380 0 : std::cout << "Memory pool size of SgExpression: " << listOfMemoryPoolSizes[V_SgExpression] << std::endl;
20381 0 : std::cout << "Memory pool size of SgExpressionRoot: " << listOfMemoryPoolSizes[V_SgExpressionRoot] << std::endl;
20382 0 : std::cout << "Memory pool size of SgFile: " << listOfMemoryPoolSizes[V_SgFile] << std::endl;
20383 0 : std::cout << "Memory pool size of SgFileList: " << listOfMemoryPoolSizes[V_SgFileList] << std::endl;
20384 0 : std::cout << "Memory pool size of SgFloatVal: " << listOfMemoryPoolSizes[V_SgFloatVal] << std::endl;
20385 0 : std::cout << "Memory pool size of SgFloat128Val: " << listOfMemoryPoolSizes[V_SgFloat128Val] << std::endl;
20386 0 : std::cout << "Memory pool size of SgFloat80Val: " << listOfMemoryPoolSizes[V_SgFloat80Val] << std::endl;
20387 0 : std::cout << "Memory pool size of SgFoldExpression: " << listOfMemoryPoolSizes[V_SgFoldExpression] << std::endl;
20388 0 : std::cout << "Memory pool size of SgFlushStatement: " << listOfMemoryPoolSizes[V_SgFlushStatement] << std::endl;
20389 0 : std::cout << "Memory pool size of SgForAllStatement: " << listOfMemoryPoolSizes[V_SgForAllStatement] << std::endl;
20390 0 : std::cout << "Memory pool size of SgForInitStatement: " << listOfMemoryPoolSizes[V_SgForInitStatement] << std::endl;
20391 0 : std::cout << "Memory pool size of SgForStatement: " << listOfMemoryPoolSizes[V_SgForStatement] << std::endl;
20392 0 : std::cout << "Memory pool size of SgFormatItem: " << listOfMemoryPoolSizes[V_SgFormatItem] << std::endl;
20393 0 : std::cout << "Memory pool size of SgFormatItemList: " << listOfMemoryPoolSizes[V_SgFormatItemList] << std::endl;
20394 0 : std::cout << "Memory pool size of SgFormatStatement: " << listOfMemoryPoolSizes[V_SgFormatStatement] << std::endl;
20395 0 : std::cout << "Memory pool size of SgFortranDo: " << listOfMemoryPoolSizes[V_SgFortranDo] << std::endl;
20396 0 : std::cout << "Memory pool size of SgFortranIncludeLine: " << listOfMemoryPoolSizes[V_SgFortranIncludeLine] << std::endl;
20397 0 : std::cout << "Memory pool size of SgFortranNonblockedDo: " << listOfMemoryPoolSizes[V_SgFortranNonblockedDo] << std::endl;
20398 0 : std::cout << "Memory pool size of SgFuncDecl_attr: " << listOfMemoryPoolSizes[V_SgFuncDecl_attr] << std::endl;
20399 0 : std::cout << "Memory pool size of SgFunctionCallExp: " << listOfMemoryPoolSizes[V_SgFunctionCallExp] << std::endl;
20400 0 : std::cout << "Memory pool size of SgFunctionDeclaration: " << listOfMemoryPoolSizes[V_SgFunctionDeclaration] << std::endl;
20401 0 : std::cout << "Memory pool size of SgFunctionDefinition: " << listOfMemoryPoolSizes[V_SgFunctionDefinition] << std::endl;
20402 0 : std::cout << "Memory pool size of SgFunctionParameterScope: " << listOfMemoryPoolSizes[V_SgFunctionParameterScope] << std::endl;
20403 0 : std::cout << "Memory pool size of SgFunctionModifier: " << listOfMemoryPoolSizes[V_SgFunctionModifier] << std::endl;
20404 0 : std::cout << "Memory pool size of SgFunctionParameterList: " << listOfMemoryPoolSizes[V_SgFunctionParameterList] << std::endl;
20405 0 : std::cout << "Memory pool size of SgFunctionParameterRefExp: " << listOfMemoryPoolSizes[V_SgFunctionParameterRefExp] << std::endl;
20406 0 : std::cout << "Memory pool size of SgFunctionParameterTypeList: " << listOfMemoryPoolSizes[V_SgFunctionParameterTypeList] << std::endl;
20407 0 : std::cout << "Memory pool size of SgFunctionRefExp: " << listOfMemoryPoolSizes[V_SgFunctionRefExp] << std::endl;
20408 0 : std::cout << "Memory pool size of SgFunctionSymbol: " << listOfMemoryPoolSizes[V_SgFunctionSymbol] << std::endl;
20409 0 : std::cout << "Memory pool size of SgFunctionType: " << listOfMemoryPoolSizes[V_SgFunctionType] << std::endl;
20410 0 : std::cout << "Memory pool size of SgFunctionTypeSymbol: " << listOfMemoryPoolSizes[V_SgFunctionTypeSymbol] << std::endl;
20411 0 : std::cout << "Memory pool size of SgFunctionTypeTable: " << listOfMemoryPoolSizes[V_SgFunctionTypeTable] << std::endl;
20412 0 : std::cout << "Memory pool size of SgTypeTable: " << listOfMemoryPoolSizes[V_SgTypeTable] << std::endl;
20413 0 : std::cout << "Memory pool size of SgGlobal: " << listOfMemoryPoolSizes[V_SgGlobal] << std::endl;
20414 0 : std::cout << "Memory pool size of SgGotoStatement: " << listOfMemoryPoolSizes[V_SgGotoStatement] << std::endl;
20415 0 : std::cout << "Memory pool size of SgGraph: " << listOfMemoryPoolSizes[V_SgGraph] << std::endl;
20416 0 : std::cout << "Memory pool size of SgGraphEdge: " << listOfMemoryPoolSizes[V_SgGraphEdge] << std::endl;
20417 0 : std::cout << "Memory pool size of SgGraphEdgeList: " << listOfMemoryPoolSizes[V_SgGraphEdgeList] << std::endl;
20418 0 : std::cout << "Memory pool size of SgGraphNode: " << listOfMemoryPoolSizes[V_SgGraphNode] << std::endl;
20419 0 : std::cout << "Memory pool size of SgGraphNodeList: " << listOfMemoryPoolSizes[V_SgGraphNodeList] << std::endl;
20420 0 : std::cout << "Memory pool size of SgGreaterOrEqualOp: " << listOfMemoryPoolSizes[V_SgGreaterOrEqualOp] << std::endl;
20421 0 : std::cout << "Memory pool size of SgGreaterThanOp: " << listOfMemoryPoolSizes[V_SgGreaterThanOp] << std::endl;
20422 0 : std::cout << "Memory pool size of SgIOItemExpression: " << listOfMemoryPoolSizes[V_SgIOItemExpression] << std::endl;
20423 0 : std::cout << "Memory pool size of SgIOStatement: " << listOfMemoryPoolSizes[V_SgIOStatement] << std::endl;
20424 0 : std::cout << "Memory pool size of SgIdentDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIdentDirectiveStatement] << std::endl;
20425 0 : std::cout << "Memory pool size of SgIfDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIfDirectiveStatement] << std::endl;
20426 0 : std::cout << "Memory pool size of SgIfStmt: " << listOfMemoryPoolSizes[V_SgIfStmt] << std::endl;
20427 0 : std::cout << "Memory pool size of SgIfdefDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIfdefDirectiveStatement] << std::endl;
20428 0 : std::cout << "Memory pool size of SgIfndefDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIfndefDirectiveStatement] << std::endl;
20429 0 : std::cout << "Memory pool size of SgImageControlStatement: " << listOfMemoryPoolSizes[V_SgImageControlStatement] << std::endl;
20430 0 : std::cout << "Memory pool size of SgImagPartOp: " << listOfMemoryPoolSizes[V_SgImagPartOp] << std::endl;
20431 0 : std::cout << "Memory pool size of SgImplicitStatement: " << listOfMemoryPoolSizes[V_SgImplicitStatement] << std::endl;
20432 0 : std::cout << "Memory pool size of SgImpliedDo: " << listOfMemoryPoolSizes[V_SgImpliedDo] << std::endl;
20433 0 : std::cout << "Memory pool size of SgImportStatement: " << listOfMemoryPoolSizes[V_SgImportStatement] << std::endl;
20434 0 : std::cout << "Memory pool size of SgIncidenceDirectedGraph: " << listOfMemoryPoolSizes[V_SgIncidenceDirectedGraph] << std::endl;
20435 0 : std::cout << "Memory pool size of SgIncidenceUndirectedGraph: " << listOfMemoryPoolSizes[V_SgIncidenceUndirectedGraph] << std::endl;
20436 0 : std::cout << "Memory pool size of SgIncludeDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIncludeDirectiveStatement] << std::endl;
20437 0 : std::cout << "Memory pool size of SgIncludeFile: " << listOfMemoryPoolSizes[V_SgIncludeFile] << std::endl;
20438 0 : std::cout << "Memory pool size of SgIncludeNextDirectiveStatement: " << listOfMemoryPoolSizes[V_SgIncludeNextDirectiveStatement] << std::endl;
20439 0 : std::cout << "Memory pool size of SgInitializedName: " << listOfMemoryPoolSizes[V_SgInitializedName] << std::endl;
20440 0 : std::cout << "Memory pool size of SgInitializer: " << listOfMemoryPoolSizes[V_SgInitializer] << std::endl;
20441 0 : std::cout << "Memory pool size of SgInquireStatement: " << listOfMemoryPoolSizes[V_SgInquireStatement] << std::endl;
20442 0 : std::cout << "Memory pool size of SgIntKeyedBidirectionalGraph: " << listOfMemoryPoolSizes[V_SgIntKeyedBidirectionalGraph] << std::endl;
20443 0 : std::cout << "Memory pool size of SgIntVal: " << listOfMemoryPoolSizes[V_SgIntVal] << std::endl;
20444 0 : std::cout << "Memory pool size of SgIntegerDivideOp: " << listOfMemoryPoolSizes[V_SgIntegerDivideOp] << std::endl;
20445 0 : std::cout << "Memory pool size of SgIntegerDivideAssignOp: " << listOfMemoryPoolSizes[V_SgIntegerDivideAssignOp] << std::endl;
20446 0 : std::cout << "Memory pool size of SgInterfaceBody: " << listOfMemoryPoolSizes[V_SgInterfaceBody] << std::endl;
20447 0 : std::cout << "Memory pool size of SgHeaderFileBody: " << listOfMemoryPoolSizes[V_SgHeaderFileBody] << std::endl;
20448 0 : std::cout << "Memory pool size of SgHeaderFileReport: " << listOfMemoryPoolSizes[V_SgHeaderFileReport] << std::endl;
20449 0 : std::cout << "Memory pool size of SgInterfaceStatement: " << listOfMemoryPoolSizes[V_SgInterfaceStatement] << std::endl;
20450 0 : std::cout << "Memory pool size of SgInterfaceSymbol: " << listOfMemoryPoolSizes[V_SgInterfaceSymbol] << std::endl;
20451 0 : std::cout << "Memory pool size of SgIntrinsicSymbol: " << listOfMemoryPoolSizes[V_SgIntrinsicSymbol] << std::endl;
20452 0 : std::cout << "Memory pool size of SgIsOp: " << listOfMemoryPoolSizes[V_SgIsOp] << std::endl;
20453 0 : std::cout << "Memory pool size of SgIsNotOp: " << listOfMemoryPoolSizes[V_SgIsNotOp] << std::endl;
20454 0 : std::cout << "Memory pool size of SgIorAssignOp: " << listOfMemoryPoolSizes[V_SgIorAssignOp] << std::endl;
20455 0 : std::cout << "Memory pool size of SgKeyDatumPair: " << listOfMemoryPoolSizes[V_SgKeyDatumPair] << std::endl;
20456 0 : std::cout << "Memory pool size of SgCudaKernelExecConfig: " << listOfMemoryPoolSizes[V_SgCudaKernelExecConfig] << std::endl;
20457 0 : std::cout << "Memory pool size of SgCudaKernelCallExp: " << listOfMemoryPoolSizes[V_SgCudaKernelCallExp] << std::endl;
20458 0 : std::cout << "Memory pool size of SgLabelRefExp: " << listOfMemoryPoolSizes[V_SgLabelRefExp] << std::endl;
20459 0 : std::cout << "Memory pool size of SgLabelStatement: " << listOfMemoryPoolSizes[V_SgLabelStatement] << std::endl;
20460 0 : std::cout << "Memory pool size of SgLabelSymbol: " << listOfMemoryPoolSizes[V_SgLabelSymbol] << std::endl;
20461 0 : std::cout << "Memory pool size of SgLambdaCapture: " << listOfMemoryPoolSizes[V_SgLambdaCapture] << std::endl;
20462 0 : std::cout << "Memory pool size of SgLambdaCaptureList: " << listOfMemoryPoolSizes[V_SgLambdaCaptureList] << std::endl;
20463 0 : std::cout << "Memory pool size of SgLambdaExp: " << listOfMemoryPoolSizes[V_SgLambdaExp] << std::endl;
20464 0 : std::cout << "Memory pool size of SgLambdaRefExp: " << listOfMemoryPoolSizes[V_SgLambdaRefExp] << std::endl;
20465 0 : std::cout << "Memory pool size of SgLeftDivideOp: " << listOfMemoryPoolSizes[V_SgLeftDivideOp] << std::endl;
20466 0 : std::cout << "Memory pool size of SgLessOrEqualOp: " << listOfMemoryPoolSizes[V_SgLessOrEqualOp] << std::endl;
20467 0 : std::cout << "Memory pool size of SgLessThanOp: " << listOfMemoryPoolSizes[V_SgLessThanOp] << std::endl;
20468 0 : std::cout << "Memory pool size of SgLineDirectiveStatement: " << listOfMemoryPoolSizes[V_SgLineDirectiveStatement] << std::endl;
20469 0 : std::cout << "Memory pool size of SgLinemarkerDirectiveStatement: " << listOfMemoryPoolSizes[V_SgLinemarkerDirectiveStatement] << std::endl;
20470 0 : std::cout << "Memory pool size of SgLinkageModifier: " << listOfMemoryPoolSizes[V_SgLinkageModifier] << std::endl;
20471 0 : std::cout << "Memory pool size of SgListComprehension: " << listOfMemoryPoolSizes[V_SgListComprehension] << std::endl;
20472 0 : std::cout << "Memory pool size of SgListExp: " << listOfMemoryPoolSizes[V_SgListExp] << std::endl;
20473 0 : std::cout << "Memory pool size of SgLocatedNode: " << listOfMemoryPoolSizes[V_SgLocatedNode] << std::endl;
20474 0 : std::cout << "Memory pool size of SgLocatedNodeSupport: " << listOfMemoryPoolSizes[V_SgLocatedNodeSupport] << std::endl;
20475 0 : std::cout << "Memory pool size of SgLongDoubleVal: " << listOfMemoryPoolSizes[V_SgLongDoubleVal] << std::endl;
20476 0 : std::cout << "Memory pool size of SgLongIntVal: " << listOfMemoryPoolSizes[V_SgLongIntVal] << std::endl;
20477 0 : std::cout << "Memory pool size of SgLongLongIntVal: " << listOfMemoryPoolSizes[V_SgLongLongIntVal] << std::endl;
20478 0 : std::cout << "Memory pool size of SgLshiftAssignOp: " << listOfMemoryPoolSizes[V_SgLshiftAssignOp] << std::endl;
20479 0 : std::cout << "Memory pool size of SgLshiftOp: " << listOfMemoryPoolSizes[V_SgLshiftOp] << std::endl;
20480 0 : std::cout << "Memory pool size of SgMagicColonExp: " << listOfMemoryPoolSizes[V_SgMagicColonExp] << std::endl;
20481 0 : std::cout << "Memory pool size of SgMatrixExp: " << listOfMemoryPoolSizes[V_SgMatrixExp] << std::endl;
20482 0 : std::cout << "Memory pool size of SgMatrixTransposeOp: " << listOfMemoryPoolSizes[V_SgMatrixTransposeOp] << std::endl;
20483 0 : std::cout << "Memory pool size of SgMemberFunctionDeclaration: " << listOfMemoryPoolSizes[V_SgMemberFunctionDeclaration] << std::endl;
20484 0 : std::cout << "Memory pool size of SgMemberFunctionRefExp: " << listOfMemoryPoolSizes[V_SgMemberFunctionRefExp] << std::endl;
20485 0 : std::cout << "Memory pool size of SgMemberFunctionSymbol: " << listOfMemoryPoolSizes[V_SgMemberFunctionSymbol] << std::endl;
20486 0 : std::cout << "Memory pool size of SgMemberFunctionType: " << listOfMemoryPoolSizes[V_SgMemberFunctionType] << std::endl;
20487 0 : std::cout << "Memory pool size of SgMembershipOp: " << listOfMemoryPoolSizes[V_SgMembershipOp] << std::endl;
20488 0 : std::cout << "Memory pool size of SgMicrosoftAttributeDeclaration: " << listOfMemoryPoolSizes[V_SgMicrosoftAttributeDeclaration] << std::endl;
20489 0 : std::cout << "Memory pool size of SgMinusAssignOp: " << listOfMemoryPoolSizes[V_SgMinusAssignOp] << std::endl;
20490 0 : std::cout << "Memory pool size of SgMinusMinusOp: " << listOfMemoryPoolSizes[V_SgMinusMinusOp] << std::endl;
20491 0 : std::cout << "Memory pool size of SgMinusOp: " << listOfMemoryPoolSizes[V_SgMinusOp] << std::endl;
20492 0 : std::cout << "Memory pool size of SgModAssignOp: " << listOfMemoryPoolSizes[V_SgModAssignOp] << std::endl;
20493 0 : std::cout << "Memory pool size of SgModOp: " << listOfMemoryPoolSizes[V_SgModOp] << std::endl;
20494 0 : std::cout << "Memory pool size of SgModifier: " << listOfMemoryPoolSizes[V_SgModifier] << std::endl;
20495 0 : std::cout << "Memory pool size of SgModifierNodes: " << listOfMemoryPoolSizes[V_SgModifierNodes] << std::endl;
20496 0 : std::cout << "Memory pool size of SgModifierType: " << listOfMemoryPoolSizes[V_SgModifierType] << std::endl;
20497 0 : std::cout << "Memory pool size of SgModuleStatement: " << listOfMemoryPoolSizes[V_SgModuleStatement] << std::endl;
20498 0 : std::cout << "Memory pool size of SgModuleSymbol: " << listOfMemoryPoolSizes[V_SgModuleSymbol] << std::endl;
20499 0 : std::cout << "Memory pool size of SgMultAssignOp: " << listOfMemoryPoolSizes[V_SgMultAssignOp] << std::endl;
20500 0 : std::cout << "Memory pool size of SgMultiplyOp: " << listOfMemoryPoolSizes[V_SgMultiplyOp] << std::endl;
20501 0 : std::cout << "Memory pool size of SgName: " << listOfMemoryPoolSizes[V_SgName] << std::endl;
20502 0 : std::cout << "Memory pool size of SgNameGroup: " << listOfMemoryPoolSizes[V_SgNameGroup] << std::endl;
20503 0 : std::cout << "Memory pool size of SgNamedType: " << listOfMemoryPoolSizes[V_SgNamedType] << std::endl;
20504 0 : std::cout << "Memory pool size of SgNamelistStatement: " << listOfMemoryPoolSizes[V_SgNamelistStatement] << std::endl;
20505 0 : std::cout << "Memory pool size of SgNamespaceAliasDeclarationStatement: " << listOfMemoryPoolSizes[V_SgNamespaceAliasDeclarationStatement] << std::endl;
20506 0 : std::cout << "Memory pool size of SgNamespaceDeclarationStatement: " << listOfMemoryPoolSizes[V_SgNamespaceDeclarationStatement] << std::endl;
20507 0 : std::cout << "Memory pool size of SgNamespaceDefinitionStatement: " << listOfMemoryPoolSizes[V_SgNamespaceDefinitionStatement] << std::endl;
20508 0 : std::cout << "Memory pool size of SgNamespaceSymbol: " << listOfMemoryPoolSizes[V_SgNamespaceSymbol] << std::endl;
20509 0 : std::cout << "Memory pool size of SgNaryOp: " << listOfMemoryPoolSizes[V_SgNaryOp] << std::endl;
20510 0 : std::cout << "Memory pool size of SgNaryBooleanOp: " << listOfMemoryPoolSizes[V_SgNaryBooleanOp] << std::endl;
20511 0 : std::cout << "Memory pool size of SgNaryComparisonOp: " << listOfMemoryPoolSizes[V_SgNaryComparisonOp] << std::endl;
20512 0 : std::cout << "Memory pool size of SgNewExp: " << listOfMemoryPoolSizes[V_SgNewExp] << std::endl;
20513 0 : std::cout << "Memory pool size of SgNode: " << listOfMemoryPoolSizes[V_SgNode] << std::endl;
20514 0 : std::cout << "Memory pool size of SgNoexceptOp: " << listOfMemoryPoolSizes[V_SgNoexceptOp] << std::endl;
20515 0 : std::cout << "Memory pool size of SgNotEqualOp: " << listOfMemoryPoolSizes[V_SgNotEqualOp] << std::endl;
20516 0 : std::cout << "Memory pool size of SgNotOp: " << listOfMemoryPoolSizes[V_SgNotOp] << std::endl;
20517 0 : std::cout << "Memory pool size of SgNonMembershipOp: " << listOfMemoryPoolSizes[V_SgNonMembershipOp] << std::endl;
20518 0 : std::cout << "Memory pool size of SgNonrealDecl: " << listOfMemoryPoolSizes[V_SgNonrealDecl] << std::endl;
20519 0 : std::cout << "Memory pool size of SgNonrealRefExp: " << listOfMemoryPoolSizes[V_SgNonrealRefExp] << std::endl;
20520 0 : std::cout << "Memory pool size of SgNonrealSymbol: " << listOfMemoryPoolSizes[V_SgNonrealSymbol] << std::endl;
20521 0 : std::cout << "Memory pool size of SgNonrealType: " << listOfMemoryPoolSizes[V_SgNonrealType] << std::endl;
20522 0 : std::cout << "Memory pool size of SgNonrealBaseClass: " << listOfMemoryPoolSizes[V_SgNonrealBaseClass] << std::endl;
20523 0 : std::cout << "Memory pool size of SgNullExpression: " << listOfMemoryPoolSizes[V_SgNullExpression] << std::endl;
20524 0 : std::cout << "Memory pool size of SgNullptrValExp: " << listOfMemoryPoolSizes[V_SgNullptrValExp] << std::endl;
20525 0 : std::cout << "Memory pool size of SgNullStatement: " << listOfMemoryPoolSizes[V_SgNullStatement] << std::endl;
20526 0 : std::cout << "Memory pool size of SgNullifyStatement: " << listOfMemoryPoolSizes[V_SgNullifyStatement] << std::endl;
20527 0 : std::cout << "Memory pool size of SgOmpAtomicStatement: " << listOfMemoryPoolSizes[V_SgOmpAtomicStatement] << std::endl;
20528 0 : std::cout << "Memory pool size of SgOmpBarrierStatement: " << listOfMemoryPoolSizes[V_SgOmpBarrierStatement] << std::endl;
20529 0 : std::cout << "Memory pool size of SgOmpCriticalStatement: " << listOfMemoryPoolSizes[V_SgOmpCriticalStatement] << std::endl;
20530 0 : std::cout << "Memory pool size of SgUpirFieldBodyStatement: " << listOfMemoryPoolSizes[V_SgUpirFieldBodyStatement] << std::endl;
20531 0 : std::cout << "Memory pool size of SgUpirBodyStatement: " << listOfMemoryPoolSizes[V_SgUpirBodyStatement] << std::endl;
20532 0 : std::cout << "Memory pool size of SgUpirFieldStatement: " << listOfMemoryPoolSizes[V_SgUpirFieldStatement] << std::endl;
20533 0 : std::cout << "Memory pool size of SgOmpDoStatement: " << listOfMemoryPoolSizes[V_SgOmpDoStatement] << std::endl;
20534 0 : std::cout << "Memory pool size of SgOmpFlushStatement: " << listOfMemoryPoolSizes[V_SgOmpFlushStatement] << std::endl;
20535 0 : std::cout << "Memory pool size of SgOmpAllocateStatement: " << listOfMemoryPoolSizes[V_SgOmpAllocateStatement] << std::endl;
20536 0 : std::cout << "Memory pool size of SgOmpDeclareSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpDeclareSimdStatement] << std::endl;
20537 0 : std::cout << "Memory pool size of SgUpirWorksharingStatement: " << listOfMemoryPoolSizes[V_SgUpirWorksharingStatement] << std::endl;
20538 0 : std::cout << "Memory pool size of SgOmpForSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpForSimdStatement] << std::endl;
20539 0 : std::cout << "Memory pool size of SgOmpMasterStatement: " << listOfMemoryPoolSizes[V_SgOmpMasterStatement] << std::endl;
20540 0 : std::cout << "Memory pool size of SgOmpTaskyieldStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskyieldStatement] << std::endl;
20541 0 : std::cout << "Memory pool size of SgOmpMetadirectiveStatement: " << listOfMemoryPoolSizes[V_SgOmpMetadirectiveStatement] << std::endl;
20542 0 : std::cout << "Memory pool size of SgOmpOrderedStatement: " << listOfMemoryPoolSizes[V_SgOmpOrderedStatement] << std::endl;
20543 0 : std::cout << "Memory pool size of SgOmpOrderedDependStatement: " << listOfMemoryPoolSizes[V_SgOmpOrderedDependStatement] << std::endl;
20544 0 : std::cout << "Memory pool size of SgUpirSpmdStatement: " << listOfMemoryPoolSizes[V_SgUpirSpmdStatement] << std::endl;
20545 0 : std::cout << "Memory pool size of SgOmpTeamsStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsStatement] << std::endl;
20546 0 : std::cout << "Memory pool size of SgOmpCancellationPointStatement: " << listOfMemoryPoolSizes[V_SgOmpCancellationPointStatement] << std::endl;
20547 0 : std::cout << "Memory pool size of SgOmpDeclareMapperStatement: " << listOfMemoryPoolSizes[V_SgOmpDeclareMapperStatement] << std::endl;
20548 0 : std::cout << "Memory pool size of SgOmpCancelStatement: " << listOfMemoryPoolSizes[V_SgOmpCancelStatement] << std::endl;
20549 0 : std::cout << "Memory pool size of SgOmpTaskgroupStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskgroupStatement] << std::endl;
20550 0 : std::cout << "Memory pool size of SgOmpDepobjStatement: " << listOfMemoryPoolSizes[V_SgOmpDepobjStatement] << std::endl;
20551 0 : std::cout << "Memory pool size of SgOmpDistributeStatement: " << listOfMemoryPoolSizes[V_SgOmpDistributeStatement] << std::endl;
20552 0 : std::cout << "Memory pool size of SgOmpLoopStatement: " << listOfMemoryPoolSizes[V_SgOmpLoopStatement] << std::endl;
20553 0 : std::cout << "Memory pool size of SgOmpScanStatement: " << listOfMemoryPoolSizes[V_SgOmpScanStatement] << std::endl;
20554 0 : std::cout << "Memory pool size of SgOmpTaskloopStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskloopStatement] << std::endl;
20555 0 : std::cout << "Memory pool size of SgOmpTargetEnterDataStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetEnterDataStatement] << std::endl;
20556 0 : std::cout << "Memory pool size of SgOmpTargetExitDataStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetExitDataStatement] << std::endl;
20557 0 : std::cout << "Memory pool size of SgOmpSectionStatement: " << listOfMemoryPoolSizes[V_SgOmpSectionStatement] << std::endl;
20558 0 : std::cout << "Memory pool size of SgOmpSectionsStatement: " << listOfMemoryPoolSizes[V_SgOmpSectionsStatement] << std::endl;
20559 0 : std::cout << "Memory pool size of SgOmpSingleStatement: " << listOfMemoryPoolSizes[V_SgOmpSingleStatement] << std::endl;
20560 0 : std::cout << "Memory pool size of SgOmpTaskStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskStatement] << std::endl;
20561 0 : std::cout << "Memory pool size of SgOmpTaskwaitStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskwaitStatement] << std::endl;
20562 0 : std::cout << "Memory pool size of SgOmpThreadprivateStatement: " << listOfMemoryPoolSizes[V_SgOmpThreadprivateStatement] << std::endl;
20563 0 : std::cout << "Memory pool size of SgOmpWorkshareStatement: " << listOfMemoryPoolSizes[V_SgOmpWorkshareStatement] << std::endl;
20564 0 : std::cout << "Memory pool size of SgUpirTaskStatement: " << listOfMemoryPoolSizes[V_SgUpirTaskStatement] << std::endl;
20565 0 : std::cout << "Memory pool size of SgOmpTargetDataStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetDataStatement] << std::endl;
20566 0 : std::cout << "Memory pool size of SgOmpTargetParallelForStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetParallelForStatement] << std::endl;
20567 0 : std::cout << "Memory pool size of SgOmpTargetUpdateStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetUpdateStatement] << std::endl;
20568 0 : std::cout << "Memory pool size of SgOmpRequiresStatement: " << listOfMemoryPoolSizes[V_SgOmpRequiresStatement] << std::endl;
20569 0 : std::cout << "Memory pool size of SgOmpTargetParallelStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetParallelStatement] << std::endl;
20570 0 : std::cout << "Memory pool size of SgOmpTargetParallelForSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetParallelForSimdStatement] << std::endl;
20571 0 : std::cout << "Memory pool size of SgOmpTargetParallelLoopStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetParallelLoopStatement] << std::endl;
20572 0 : std::cout << "Memory pool size of SgOmpTargetSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetSimdStatement] << std::endl;
20573 0 : std::cout << "Memory pool size of SgOmpTargetTeamsStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsStatement] << std::endl;
20574 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsDistributeStatement] << std::endl;
20575 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsDistributeSimdStatement] << std::endl;
20576 0 : std::cout << "Memory pool size of SgOmpTargetTeamsLoopStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsLoopStatement] << std::endl;
20577 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeParallelForStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsDistributeParallelForStatement] << std::endl;
20578 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeParallelForSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTargetTeamsDistributeParallelForSimdStatement] << std::endl;
20579 0 : std::cout << "Memory pool size of SgOmpDistributeSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpDistributeSimdStatement] << std::endl;
20580 0 : std::cout << "Memory pool size of SgOmpDistributeParallelForStatement: " << listOfMemoryPoolSizes[V_SgOmpDistributeParallelForStatement] << std::endl;
20581 0 : std::cout << "Memory pool size of SgOmpDistributeParallelForSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpDistributeParallelForSimdStatement] << std::endl;
20582 0 : std::cout << "Memory pool size of SgOmpTaskloopSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTaskloopSimdStatement] << std::endl;
20583 0 : std::cout << "Memory pool size of SgOmpMasterTaskloopSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpMasterTaskloopSimdStatement] << std::endl;
20584 0 : std::cout << "Memory pool size of SgOmpParallelMasterTaskloopStatement: " << listOfMemoryPoolSizes[V_SgOmpParallelMasterTaskloopStatement] << std::endl;
20585 0 : std::cout << "Memory pool size of SgOmpParallelMasterTaskloopSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpParallelMasterTaskloopSimdStatement] << std::endl;
20586 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsDistributeStatement] << std::endl;
20587 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsDistributeSimdStatement] << std::endl;
20588 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeParallelForStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsDistributeParallelForStatement] << std::endl;
20589 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeParallelForSimdStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsDistributeParallelForSimdStatement] << std::endl;
20590 0 : std::cout << "Memory pool size of SgOmpTeamsLoopStatement: " << listOfMemoryPoolSizes[V_SgOmpTeamsLoopStatement] << std::endl;
20591 0 : std::cout << "Memory pool size of SgOmpParallelLoopStatement: " << listOfMemoryPoolSizes[V_SgOmpParallelLoopStatement] << std::endl;
20592 0 : std::cout << "Memory pool size of SgOmpParallelMasterStatement: " << listOfMemoryPoolSizes[V_SgOmpParallelMasterStatement] << std::endl;
20593 0 : std::cout << "Memory pool size of SgOmpMasterTaskloopStatement: " << listOfMemoryPoolSizes[V_SgOmpMasterTaskloopStatement] << std::endl;
20594 0 : std::cout << "Memory pool size of SgOmpUnrollStatement: " << listOfMemoryPoolSizes[V_SgOmpUnrollStatement] << std::endl;
20595 0 : std::cout << "Memory pool size of SgOmpTileStatement: " << listOfMemoryPoolSizes[V_SgOmpTileStatement] << std::endl;
20596 0 : std::cout << "Memory pool size of SgUpirSimdStatement: " << listOfMemoryPoolSizes[V_SgUpirSimdStatement] << std::endl;
20597 0 : std::cout << "Memory pool size of SgUpirBaseStatement: " << listOfMemoryPoolSizes[V_SgUpirBaseStatement] << std::endl;
20598 0 : std::cout << "Memory pool size of SgUpirLoopStatement: " << listOfMemoryPoolSizes[V_SgUpirLoopStatement] << std::endl;
20599 0 : std::cout << "Memory pool size of SgUpirLoopParallelStatement: " << listOfMemoryPoolSizes[V_SgUpirLoopParallelStatement] << std::endl;
20600 0 : std::cout << "Memory pool size of SgUpirSyncStatement: " << listOfMemoryPoolSizes[V_SgUpirSyncStatement] << std::endl;
20601 0 : std::cout << "Memory pool size of SgOmpClause: " << listOfMemoryPoolSizes[V_SgOmpClause] << std::endl;
20602 0 : std::cout << "Memory pool size of SgOmpAllocateClause: " << listOfMemoryPoolSizes[V_SgOmpAllocateClause] << std::endl;
20603 0 : std::cout << "Memory pool size of SgOmpAllocatorClause: " << listOfMemoryPoolSizes[V_SgOmpAllocatorClause] << std::endl;
20604 0 : std::cout << "Memory pool size of SgOmpUsesAllocatorsClause: " << listOfMemoryPoolSizes[V_SgOmpUsesAllocatorsClause] << std::endl;
20605 0 : std::cout << "Memory pool size of SgOmpUsesAllocatorsDefination: " << listOfMemoryPoolSizes[V_SgOmpUsesAllocatorsDefination] << std::endl;
20606 0 : std::cout << "Memory pool size of SgOmpToClause: " << listOfMemoryPoolSizes[V_SgOmpToClause] << std::endl;
20607 0 : std::cout << "Memory pool size of SgOmpFromClause: " << listOfMemoryPoolSizes[V_SgOmpFromClause] << std::endl;
20608 0 : std::cout << "Memory pool size of SgOmpThreadsClause: " << listOfMemoryPoolSizes[V_SgOmpThreadsClause] << std::endl;
20609 0 : std::cout << "Memory pool size of SgOmpSimdClause: " << listOfMemoryPoolSizes[V_SgOmpSimdClause] << std::endl;
20610 0 : std::cout << "Memory pool size of SgOmpBeginClause: " << listOfMemoryPoolSizes[V_SgOmpBeginClause] << std::endl;
20611 0 : std::cout << "Memory pool size of SgOmpCollapseClause: " << listOfMemoryPoolSizes[V_SgOmpCollapseClause] << std::endl;
20612 0 : std::cout << "Memory pool size of SgOmpCopyinClause: " << listOfMemoryPoolSizes[V_SgOmpCopyinClause] << std::endl;
20613 0 : std::cout << "Memory pool size of SgOmpCopyprivateClause: " << listOfMemoryPoolSizes[V_SgOmpCopyprivateClause] << std::endl;
20614 0 : std::cout << "Memory pool size of SgOmpDefaultClause: " << listOfMemoryPoolSizes[V_SgOmpDefaultClause] << std::endl;
20615 0 : std::cout << "Memory pool size of SgOmpEndClause: " << listOfMemoryPoolSizes[V_SgOmpEndClause] << std::endl;
20616 0 : std::cout << "Memory pool size of SgOmpExpressionClause: " << listOfMemoryPoolSizes[V_SgOmpExpressionClause] << std::endl;
20617 0 : std::cout << "Memory pool size of SgOmpFirstprivateClause: " << listOfMemoryPoolSizes[V_SgOmpFirstprivateClause] << std::endl;
20618 0 : std::cout << "Memory pool size of SgOmpIfClause: " << listOfMemoryPoolSizes[V_SgOmpIfClause] << std::endl;
20619 0 : std::cout << "Memory pool size of SgOmpFinalClause: " << listOfMemoryPoolSizes[V_SgOmpFinalClause] << std::endl;
20620 0 : std::cout << "Memory pool size of SgOmpPriorityClause: " << listOfMemoryPoolSizes[V_SgOmpPriorityClause] << std::endl;
20621 0 : std::cout << "Memory pool size of SgOmpDeviceClause: " << listOfMemoryPoolSizes[V_SgOmpDeviceClause] << std::endl;
20622 0 : std::cout << "Memory pool size of SgOmpLastprivateClause: " << listOfMemoryPoolSizes[V_SgOmpLastprivateClause] << std::endl;
20623 0 : std::cout << "Memory pool size of SgOmpNowaitClause: " << listOfMemoryPoolSizes[V_SgOmpNowaitClause] << std::endl;
20624 0 : std::cout << "Memory pool size of SgOmpReadClause: " << listOfMemoryPoolSizes[V_SgOmpReadClause] << std::endl;
20625 0 : std::cout << "Memory pool size of SgOmpWriteClause: " << listOfMemoryPoolSizes[V_SgOmpWriteClause] << std::endl;
20626 0 : std::cout << "Memory pool size of SgOmpUpdateClause: " << listOfMemoryPoolSizes[V_SgOmpUpdateClause] << std::endl;
20627 0 : std::cout << "Memory pool size of SgOmpDepobjUpdateClause: " << listOfMemoryPoolSizes[V_SgOmpDepobjUpdateClause] << std::endl;
20628 0 : std::cout << "Memory pool size of SgOmpDestroyClause: " << listOfMemoryPoolSizes[V_SgOmpDestroyClause] << std::endl;
20629 0 : std::cout << "Memory pool size of SgOmpCaptureClause: " << listOfMemoryPoolSizes[V_SgOmpCaptureClause] << std::endl;
20630 0 : std::cout << "Memory pool size of SgOmpSeqCstClause: " << listOfMemoryPoolSizes[V_SgOmpSeqCstClause] << std::endl;
20631 0 : std::cout << "Memory pool size of SgOmpAcqRelClause: " << listOfMemoryPoolSizes[V_SgOmpAcqRelClause] << std::endl;
20632 0 : std::cout << "Memory pool size of SgOmpReleaseClause: " << listOfMemoryPoolSizes[V_SgOmpReleaseClause] << std::endl;
20633 0 : std::cout << "Memory pool size of SgOmpAcquireClause: " << listOfMemoryPoolSizes[V_SgOmpAcquireClause] << std::endl;
20634 0 : std::cout << "Memory pool size of SgOmpReverseOffloadClause: " << listOfMemoryPoolSizes[V_SgOmpReverseOffloadClause] << std::endl;
20635 0 : std::cout << "Memory pool size of SgOmpUnifiedAddressClause: " << listOfMemoryPoolSizes[V_SgOmpUnifiedAddressClause] << std::endl;
20636 0 : std::cout << "Memory pool size of SgOmpUnifiedSharedMemoryClause: " << listOfMemoryPoolSizes[V_SgOmpUnifiedSharedMemoryClause] << std::endl;
20637 0 : std::cout << "Memory pool size of SgOmpDynamicAllocatorsClause: " << listOfMemoryPoolSizes[V_SgOmpDynamicAllocatorsClause] << std::endl;
20638 0 : std::cout << "Memory pool size of SgOmpAtomicDefaultMemOrderClause: " << listOfMemoryPoolSizes[V_SgOmpAtomicDefaultMemOrderClause] << std::endl;
20639 0 : std::cout << "Memory pool size of SgOmpExtImplementationDefinedRequirementClause: " << listOfMemoryPoolSizes[V_SgOmpExtImplementationDefinedRequirementClause] << std::endl;
20640 0 : std::cout << "Memory pool size of SgOmpRelaxedClause: " << listOfMemoryPoolSizes[V_SgOmpRelaxedClause] << std::endl;
20641 0 : std::cout << "Memory pool size of SgOmpParallelClause: " << listOfMemoryPoolSizes[V_SgOmpParallelClause] << std::endl;
20642 0 : std::cout << "Memory pool size of SgOmpSectionsClause: " << listOfMemoryPoolSizes[V_SgOmpSectionsClause] << std::endl;
20643 0 : std::cout << "Memory pool size of SgOmpForClause: " << listOfMemoryPoolSizes[V_SgOmpForClause] << std::endl;
20644 0 : std::cout << "Memory pool size of SgOmpTaskgroupClause: " << listOfMemoryPoolSizes[V_SgOmpTaskgroupClause] << std::endl;
20645 0 : std::cout << "Memory pool size of SgUpirNumUnitsField: " << listOfMemoryPoolSizes[V_SgUpirNumUnitsField] << std::endl;
20646 0 : std::cout << "Memory pool size of SgOmpNumTeamsClause: " << listOfMemoryPoolSizes[V_SgOmpNumTeamsClause] << std::endl;
20647 0 : std::cout << "Memory pool size of SgOmpGrainsizeClause: " << listOfMemoryPoolSizes[V_SgOmpGrainsizeClause] << std::endl;
20648 0 : std::cout << "Memory pool size of SgOmpDetachClause: " << listOfMemoryPoolSizes[V_SgOmpDetachClause] << std::endl;
20649 0 : std::cout << "Memory pool size of SgOmpNumTasksClause: " << listOfMemoryPoolSizes[V_SgOmpNumTasksClause] << std::endl;
20650 0 : std::cout << "Memory pool size of SgOmpNogroupClause: " << listOfMemoryPoolSizes[V_SgOmpNogroupClause] << std::endl;
20651 0 : std::cout << "Memory pool size of SgOmpHintClause: " << listOfMemoryPoolSizes[V_SgOmpHintClause] << std::endl;
20652 0 : std::cout << "Memory pool size of SgOmpOrderClause: " << listOfMemoryPoolSizes[V_SgOmpOrderClause] << std::endl;
20653 0 : std::cout << "Memory pool size of SgOmpDistScheduleClause: " << listOfMemoryPoolSizes[V_SgOmpDistScheduleClause] << std::endl;
20654 0 : std::cout << "Memory pool size of SgOmpBindClause: " << listOfMemoryPoolSizes[V_SgOmpBindClause] << std::endl;
20655 0 : std::cout << "Memory pool size of SgOmpNontemporalClause: " << listOfMemoryPoolSizes[V_SgOmpNontemporalClause] << std::endl;
20656 0 : std::cout << "Memory pool size of SgOmpInclusiveClause: " << listOfMemoryPoolSizes[V_SgOmpInclusiveClause] << std::endl;
20657 0 : std::cout << "Memory pool size of SgOmpExclusiveClause: " << listOfMemoryPoolSizes[V_SgOmpExclusiveClause] << std::endl;
20658 0 : std::cout << "Memory pool size of SgOmpIsDevicePtrClause: " << listOfMemoryPoolSizes[V_SgOmpIsDevicePtrClause] << std::endl;
20659 0 : std::cout << "Memory pool size of SgOmpUseDevicePtrClause: " << listOfMemoryPoolSizes[V_SgOmpUseDevicePtrClause] << std::endl;
20660 0 : std::cout << "Memory pool size of SgOmpUseDeviceAddrClause: " << listOfMemoryPoolSizes[V_SgOmpUseDeviceAddrClause] << std::endl;
20661 0 : std::cout << "Memory pool size of SgOmpThreadLimitClause: " << listOfMemoryPoolSizes[V_SgOmpThreadLimitClause] << std::endl;
20662 0 : std::cout << "Memory pool size of SgOmpOrderedClause: " << listOfMemoryPoolSizes[V_SgOmpOrderedClause] << std::endl;
20663 0 : std::cout << "Memory pool size of SgOmpPrivateClause: " << listOfMemoryPoolSizes[V_SgOmpPrivateClause] << std::endl;
20664 0 : std::cout << "Memory pool size of SgOmpReductionClause: " << listOfMemoryPoolSizes[V_SgOmpReductionClause] << std::endl;
20665 0 : std::cout << "Memory pool size of SgOmpInReductionClause: " << listOfMemoryPoolSizes[V_SgOmpInReductionClause] << std::endl;
20666 0 : std::cout << "Memory pool size of SgOmpTaskReductionClause: " << listOfMemoryPoolSizes[V_SgOmpTaskReductionClause] << std::endl;
20667 0 : std::cout << "Memory pool size of SgOmpDefaultmapClause: " << listOfMemoryPoolSizes[V_SgOmpDefaultmapClause] << std::endl;
20668 0 : std::cout << "Memory pool size of SgOmpScheduleClause: " << listOfMemoryPoolSizes[V_SgOmpScheduleClause] << std::endl;
20669 0 : std::cout << "Memory pool size of SgOmpSharedClause: " << listOfMemoryPoolSizes[V_SgOmpSharedClause] << std::endl;
20670 0 : std::cout << "Memory pool size of SgOmpUntiedClause: " << listOfMemoryPoolSizes[V_SgOmpUntiedClause] << std::endl;
20671 0 : std::cout << "Memory pool size of SgOmpMergeableClause: " << listOfMemoryPoolSizes[V_SgOmpMergeableClause] << std::endl;
20672 0 : std::cout << "Memory pool size of SgOmpVariablesClause: " << listOfMemoryPoolSizes[V_SgOmpVariablesClause] << std::endl;
20673 0 : std::cout << "Memory pool size of SgOmpMapClause: " << listOfMemoryPoolSizes[V_SgOmpMapClause] << std::endl;
20674 0 : std::cout << "Memory pool size of SgOmpSafelenClause: " << listOfMemoryPoolSizes[V_SgOmpSafelenClause] << std::endl;
20675 0 : std::cout << "Memory pool size of SgOmpSimdlenClause: " << listOfMemoryPoolSizes[V_SgOmpSimdlenClause] << std::endl;
20676 0 : std::cout << "Memory pool size of SgOmpLinearClause: " << listOfMemoryPoolSizes[V_SgOmpLinearClause] << std::endl;
20677 0 : std::cout << "Memory pool size of SgOmpUniformClause: " << listOfMemoryPoolSizes[V_SgOmpUniformClause] << std::endl;
20678 0 : std::cout << "Memory pool size of SgOmpAlignedClause: " << listOfMemoryPoolSizes[V_SgOmpAlignedClause] << std::endl;
20679 0 : std::cout << "Memory pool size of SgOmpProcBindClause: " << listOfMemoryPoolSizes[V_SgOmpProcBindClause] << std::endl;
20680 0 : std::cout << "Memory pool size of SgOmpAtomicClause: " << listOfMemoryPoolSizes[V_SgOmpAtomicClause] << std::endl;
20681 0 : std::cout << "Memory pool size of SgOmpInbranchClause: " << listOfMemoryPoolSizes[V_SgOmpInbranchClause] << std::endl;
20682 0 : std::cout << "Memory pool size of SgOmpNotinbranchClause: " << listOfMemoryPoolSizes[V_SgOmpNotinbranchClause] << std::endl;
20683 0 : std::cout << "Memory pool size of SgOmpDependClause: " << listOfMemoryPoolSizes[V_SgOmpDependClause] << std::endl;
20684 0 : std::cout << "Memory pool size of SgOmpAffinityClause: " << listOfMemoryPoolSizes[V_SgOmpAffinityClause] << std::endl;
20685 0 : std::cout << "Memory pool size of SgOmpWhenClause: " << listOfMemoryPoolSizes[V_SgOmpWhenClause] << std::endl;
20686 0 : std::cout << "Memory pool size of SgOmpFullClause: " << listOfMemoryPoolSizes[V_SgOmpFullClause] << std::endl;
20687 0 : std::cout << "Memory pool size of SgOmpPartialClause: " << listOfMemoryPoolSizes[V_SgOmpPartialClause] << std::endl;
20688 0 : std::cout << "Memory pool size of SgOmpSizesClause: " << listOfMemoryPoolSizes[V_SgOmpSizesClause] << std::endl;
20689 0 : std::cout << "Memory pool size of SgUpirBranchField: " << listOfMemoryPoolSizes[V_SgUpirBranchField] << std::endl;
20690 0 : std::cout << "Memory pool size of SgUpirNestedLevelField: " << listOfMemoryPoolSizes[V_SgUpirNestedLevelField] << std::endl;
20691 0 : std::cout << "Memory pool size of SgUpirNestedParentField: " << listOfMemoryPoolSizes[V_SgUpirNestedParentField] << std::endl;
20692 0 : std::cout << "Memory pool size of SgUpirNestedChildField: " << listOfMemoryPoolSizes[V_SgUpirNestedChildField] << std::endl;
20693 0 : std::cout << "Memory pool size of SgUpirSyncField: " << listOfMemoryPoolSizes[V_SgUpirSyncField] << std::endl;
20694 0 : std::cout << "Memory pool size of SgUpirDataField: " << listOfMemoryPoolSizes[V_SgUpirDataField] << std::endl;
20695 0 : std::cout << "Memory pool size of SgUpirDataItemField: " << listOfMemoryPoolSizes[V_SgUpirDataItemField] << std::endl;
20696 0 : std::cout << "Memory pool size of SgUpirTargetField: " << listOfMemoryPoolSizes[V_SgUpirTargetField] << std::endl;
20697 0 : std::cout << "Memory pool size of SgOpenclAccessModeModifier: " << listOfMemoryPoolSizes[V_SgOpenclAccessModeModifier] << std::endl;
20698 0 : std::cout << "Memory pool size of SgOpenStatement: " << listOfMemoryPoolSizes[V_SgOpenStatement] << std::endl;
20699 0 : std::cout << "Memory pool size of SgOptions: " << listOfMemoryPoolSizes[V_SgOptions] << std::endl;
20700 0 : std::cout << "Memory pool size of SgOrOp: " << listOfMemoryPoolSizes[V_SgOrOp] << std::endl;
20701 0 : std::cout << "Memory pool size of SgParameterStatement: " << listOfMemoryPoolSizes[V_SgParameterStatement] << std::endl;
20702 0 : std::cout << "Memory pool size of SgPartialFunctionModifierType: " << listOfMemoryPoolSizes[V_SgPartialFunctionModifierType] << std::endl;
20703 0 : std::cout << "Memory pool size of SgPartialFunctionType: " << listOfMemoryPoolSizes[V_SgPartialFunctionType] << std::endl;
20704 0 : std::cout << "Memory pool size of SgPassStatement: " << listOfMemoryPoolSizes[V_SgPassStatement] << std::endl;
20705 0 : std::cout << "Memory pool size of SgPlusAssignOp: " << listOfMemoryPoolSizes[V_SgPlusAssignOp] << std::endl;
20706 0 : std::cout << "Memory pool size of SgPlusPlusOp: " << listOfMemoryPoolSizes[V_SgPlusPlusOp] << std::endl;
20707 0 : std::cout << "Memory pool size of SgPntrArrRefExp: " << listOfMemoryPoolSizes[V_SgPntrArrRefExp] << std::endl;
20708 0 : std::cout << "Memory pool size of SgPointerAssignOp: " << listOfMemoryPoolSizes[V_SgPointerAssignOp] << std::endl;
20709 0 : std::cout << "Memory pool size of SgPointerDerefExp: " << listOfMemoryPoolSizes[V_SgPointerDerefExp] << std::endl;
20710 0 : std::cout << "Memory pool size of SgPointerMemberType: " << listOfMemoryPoolSizes[V_SgPointerMemberType] << std::endl;
20711 0 : std::cout << "Memory pool size of SgPointerType: " << listOfMemoryPoolSizes[V_SgPointerType] << std::endl;
20712 0 : std::cout << "Memory pool size of SgPowerOp: " << listOfMemoryPoolSizes[V_SgPowerOp] << std::endl;
20713 0 : std::cout << "Memory pool size of SgPragma: " << listOfMemoryPoolSizes[V_SgPragma] << std::endl;
20714 0 : std::cout << "Memory pool size of SgPragmaDeclaration: " << listOfMemoryPoolSizes[V_SgPragmaDeclaration] << std::endl;
20715 0 : std::cout << "Memory pool size of SgPrintStatement: " << listOfMemoryPoolSizes[V_SgPrintStatement] << std::endl;
20716 0 : std::cout << "Memory pool size of SgProcedureHeaderStatement: " << listOfMemoryPoolSizes[V_SgProcedureHeaderStatement] << std::endl;
20717 0 : std::cout << "Memory pool size of SgProgramHeaderStatement: " << listOfMemoryPoolSizes[V_SgProgramHeaderStatement] << std::endl;
20718 0 : std::cout << "Memory pool size of SgProject: " << listOfMemoryPoolSizes[V_SgProject] << std::endl;
20719 0 : std::cout << "Memory pool size of SgPseudoDestructorRefExp: " << listOfMemoryPoolSizes[V_SgPseudoDestructorRefExp] << std::endl;
20720 0 : std::cout << "Memory pool size of SgQualifiedName: " << listOfMemoryPoolSizes[V_SgQualifiedName] << std::endl;
20721 0 : std::cout << "Memory pool size of SgQualifiedNameType: " << listOfMemoryPoolSizes[V_SgQualifiedNameType] << std::endl;
20722 0 : std::cout << "Memory pool size of SgRangeExp: " << listOfMemoryPoolSizes[V_SgRangeExp] << std::endl;
20723 0 : std::cout << "Memory pool size of SgRangeBasedForStatement: " << listOfMemoryPoolSizes[V_SgRangeBasedForStatement] << std::endl;
20724 0 : std::cout << "Memory pool size of SgReadStatement: " << listOfMemoryPoolSizes[V_SgReadStatement] << std::endl;
20725 0 : std::cout << "Memory pool size of SgRealPartOp: " << listOfMemoryPoolSizes[V_SgRealPartOp] << std::endl;
20726 0 : std::cout << "Memory pool size of SgRefExp: " << listOfMemoryPoolSizes[V_SgRefExp] << std::endl;
20727 0 : std::cout << "Memory pool size of SgReferenceType: " << listOfMemoryPoolSizes[V_SgReferenceType] << std::endl;
20728 0 : std::cout << "Memory pool size of SgRenamePair: " << listOfMemoryPoolSizes[V_SgRenamePair] << std::endl;
20729 0 : std::cout << "Memory pool size of SgRenameSymbol: " << listOfMemoryPoolSizes[V_SgRenameSymbol] << std::endl;
20730 0 : std::cout << "Memory pool size of SgReturnStmt: " << listOfMemoryPoolSizes[V_SgReturnStmt] << std::endl;
20731 0 : std::cout << "Memory pool size of SgRewindStatement: " << listOfMemoryPoolSizes[V_SgRewindStatement] << std::endl;
20732 0 : std::cout << "Memory pool size of SgRshiftAssignOp: " << listOfMemoryPoolSizes[V_SgRshiftAssignOp] << std::endl;
20733 0 : std::cout << "Memory pool size of SgRshiftOp: " << listOfMemoryPoolSizes[V_SgRshiftOp] << std::endl;
20734 0 : std::cout << "Memory pool size of SgRvalueReferenceType: " << listOfMemoryPoolSizes[V_SgRvalueReferenceType] << std::endl;
20735 0 : std::cout << "Memory pool size of SgScopeOp: " << listOfMemoryPoolSizes[V_SgScopeOp] << std::endl;
20736 0 : std::cout << "Memory pool size of SgScopeStatement: " << listOfMemoryPoolSizes[V_SgScopeStatement] << std::endl;
20737 0 : std::cout << "Memory pool size of SgSequenceStatement: " << listOfMemoryPoolSizes[V_SgSequenceStatement] << std::endl;
20738 0 : std::cout << "Memory pool size of SgSetComprehension: " << listOfMemoryPoolSizes[V_SgSetComprehension] << std::endl;
20739 0 : std::cout << "Memory pool size of SgShortVal: " << listOfMemoryPoolSizes[V_SgShortVal] << std::endl;
20740 0 : std::cout << "Memory pool size of SgSIMDBinaryOp: " << listOfMemoryPoolSizes[V_SgSIMDBinaryOp] << std::endl;
20741 0 : std::cout << "Memory pool size of SgSIMDAddOp: " << listOfMemoryPoolSizes[V_SgSIMDAddOp] << std::endl;
20742 0 : std::cout << "Memory pool size of SgSIMDSubOp: " << listOfMemoryPoolSizes[V_SgSIMDSubOp] << std::endl;
20743 0 : std::cout << "Memory pool size of SgSIMDMulOp: " << listOfMemoryPoolSizes[V_SgSIMDMulOp] << std::endl;
20744 0 : std::cout << "Memory pool size of SgSIMDDivOp: " << listOfMemoryPoolSizes[V_SgSIMDDivOp] << std::endl;
20745 0 : std::cout << "Memory pool size of SgSIMDFmaOp: " << listOfMemoryPoolSizes[V_SgSIMDFmaOp] << std::endl;
20746 0 : std::cout << "Memory pool size of SgSIMDLoad: " << listOfMemoryPoolSizes[V_SgSIMDLoad] << std::endl;
20747 0 : std::cout << "Memory pool size of SgSIMDBroadcast: " << listOfMemoryPoolSizes[V_SgSIMDBroadcast] << std::endl;
20748 0 : std::cout << "Memory pool size of SgSIMDStore: " << listOfMemoryPoolSizes[V_SgSIMDStore] << std::endl;
20749 0 : std::cout << "Memory pool size of SgSIMDPartialStore: " << listOfMemoryPoolSizes[V_SgSIMDPartialStore] << std::endl;
20750 0 : std::cout << "Memory pool size of SgSIMDScalarStore: " << listOfMemoryPoolSizes[V_SgSIMDScalarStore] << std::endl;
20751 0 : std::cout << "Memory pool size of SgSIMDGather: " << listOfMemoryPoolSizes[V_SgSIMDGather] << std::endl;
20752 0 : std::cout << "Memory pool size of SgSIMDExplicitGather: " << listOfMemoryPoolSizes[V_SgSIMDExplicitGather] << std::endl;
20753 0 : std::cout << "Memory pool size of SgSIMDScatter: " << listOfMemoryPoolSizes[V_SgSIMDScatter] << std::endl;
20754 0 : std::cout << "Memory pool size of SgSizeOfOp: " << listOfMemoryPoolSizes[V_SgSizeOfOp] << std::endl;
20755 0 : std::cout << "Memory pool size of SgAlignOfOp: " << listOfMemoryPoolSizes[V_SgAlignOfOp] << std::endl;
20756 0 : std::cout << "Memory pool size of SgSourceFile: " << listOfMemoryPoolSizes[V_SgSourceFile] << std::endl;
20757 0 : std::cout << "Memory pool size of SgSpaceshipOp: " << listOfMemoryPoolSizes[V_SgSpaceshipOp] << std::endl;
20758 0 : std::cout << "Memory pool size of SgSpawnStmt: " << listOfMemoryPoolSizes[V_SgSpawnStmt] << std::endl;
20759 0 : std::cout << "Memory pool size of SgSyncAllStatement: " << listOfMemoryPoolSizes[V_SgSyncAllStatement] << std::endl;
20760 0 : std::cout << "Memory pool size of SgSyncImagesStatement: " << listOfMemoryPoolSizes[V_SgSyncImagesStatement] << std::endl;
20761 0 : std::cout << "Memory pool size of SgSyncMemoryStatement: " << listOfMemoryPoolSizes[V_SgSyncMemoryStatement] << std::endl;
20762 0 : std::cout << "Memory pool size of SgSyncTeamStatement: " << listOfMemoryPoolSizes[V_SgSyncTeamStatement] << std::endl;
20763 0 : std::cout << "Memory pool size of SgLockStatement: " << listOfMemoryPoolSizes[V_SgLockStatement] << std::endl;
20764 0 : std::cout << "Memory pool size of SgUnlockStatement: " << listOfMemoryPoolSizes[V_SgUnlockStatement] << std::endl;
20765 0 : std::cout << "Memory pool size of SgProcessControlStatement: " << listOfMemoryPoolSizes[V_SgProcessControlStatement] << std::endl;
20766 0 : std::cout << "Memory pool size of SgSpecialFunctionModifier: " << listOfMemoryPoolSizes[V_SgSpecialFunctionModifier] << std::endl;
20767 0 : std::cout << "Memory pool size of SgStatement: " << listOfMemoryPoolSizes[V_SgStatement] << std::endl;
20768 0 : std::cout << "Memory pool size of SgStaticAssertionDeclaration: " << listOfMemoryPoolSizes[V_SgStaticAssertionDeclaration] << std::endl;
20769 0 : std::cout << "Memory pool size of SgStmtDeclarationStatement: " << listOfMemoryPoolSizes[V_SgStmtDeclarationStatement] << std::endl;
20770 0 : std::cout << "Memory pool size of SgStatementExpression: " << listOfMemoryPoolSizes[V_SgStatementExpression] << std::endl;
20771 0 : std::cout << "Memory pool size of SgStatementFunctionStatement: " << listOfMemoryPoolSizes[V_SgStatementFunctionStatement] << std::endl;
20772 0 : std::cout << "Memory pool size of SgStorageModifier: " << listOfMemoryPoolSizes[V_SgStorageModifier] << std::endl;
20773 0 : std::cout << "Memory pool size of SgStringConversion: " << listOfMemoryPoolSizes[V_SgStringConversion] << std::endl;
20774 0 : std::cout << "Memory pool size of SgStringKeyedBidirectionalGraph: " << listOfMemoryPoolSizes[V_SgStringKeyedBidirectionalGraph] << std::endl;
20775 0 : std::cout << "Memory pool size of SgStringVal: " << listOfMemoryPoolSizes[V_SgStringVal] << std::endl;
20776 0 : std::cout << "Memory pool size of SgStructureModifier: " << listOfMemoryPoolSizes[V_SgStructureModifier] << std::endl;
20777 0 : std::cout << "Memory pool size of SgSubscriptExpression: " << listOfMemoryPoolSizes[V_SgSubscriptExpression] << std::endl;
20778 0 : std::cout << "Memory pool size of SgSubtractOp: " << listOfMemoryPoolSizes[V_SgSubtractOp] << std::endl;
20779 0 : std::cout << "Memory pool size of SgSupport: " << listOfMemoryPoolSizes[V_SgSupport] << std::endl;
20780 0 : std::cout << "Memory pool size of SgSwitchStatement: " << listOfMemoryPoolSizes[V_SgSwitchStatement] << std::endl;
20781 0 : std::cout << "Memory pool size of SgSymbol: " << listOfMemoryPoolSizes[V_SgSymbol] << std::endl;
20782 0 : std::cout << "Memory pool size of SgSymbolTable: " << listOfMemoryPoolSizes[V_SgSymbolTable] << std::endl;
20783 0 : std::cout << "Memory pool size of SgTemplateArgument: " << listOfMemoryPoolSizes[V_SgTemplateArgument] << std::endl;
20784 0 : std::cout << "Memory pool size of SgTemplateArgumentList: " << listOfMemoryPoolSizes[V_SgTemplateArgumentList] << std::endl;
20785 0 : std::cout << "Memory pool size of SgTemplateDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateDeclaration] << std::endl;
20786 0 : std::cout << "Memory pool size of SgTemplateClassDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateClassDeclaration] << std::endl;
20787 0 : std::cout << "Memory pool size of SgTemplateClassSymbol: " << listOfMemoryPoolSizes[V_SgTemplateClassSymbol] << std::endl;
20788 0 : std::cout << "Memory pool size of SgTemplateFunctionDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateFunctionDeclaration] << std::endl;
20789 0 : std::cout << "Memory pool size of SgTemplateFunctionRefExp: " << listOfMemoryPoolSizes[V_SgTemplateFunctionRefExp] << std::endl;
20790 0 : std::cout << "Memory pool size of SgTemplateFunctionSymbol: " << listOfMemoryPoolSizes[V_SgTemplateFunctionSymbol] << std::endl;
20791 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateMemberFunctionDeclaration] << std::endl;
20792 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionRefExp: " << listOfMemoryPoolSizes[V_SgTemplateMemberFunctionRefExp] << std::endl;
20793 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionSymbol: " << listOfMemoryPoolSizes[V_SgTemplateMemberFunctionSymbol] << std::endl;
20794 0 : std::cout << "Memory pool size of SgTemplateTypedefDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateTypedefDeclaration] << std::endl;
20795 0 : std::cout << "Memory pool size of SgTemplateTypedefSymbol: " << listOfMemoryPoolSizes[V_SgTemplateTypedefSymbol] << std::endl;
20796 0 : std::cout << "Memory pool size of SgTemplateVariableDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateVariableDeclaration] << std::endl;
20797 0 : std::cout << "Memory pool size of SgTemplateVariableSymbol: " << listOfMemoryPoolSizes[V_SgTemplateVariableSymbol] << std::endl;
20798 0 : std::cout << "Memory pool size of SgTemplateClassDefinition: " << listOfMemoryPoolSizes[V_SgTemplateClassDefinition] << std::endl;
20799 0 : std::cout << "Memory pool size of SgTemplateFunctionDefinition: " << listOfMemoryPoolSizes[V_SgTemplateFunctionDefinition] << std::endl;
20800 0 : std::cout << "Memory pool size of SgTemplateInstantiationDecl: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationDecl] << std::endl;
20801 0 : std::cout << "Memory pool size of SgTemplateInstantiationDefn: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationDefn] << std::endl;
20802 0 : std::cout << "Memory pool size of SgTemplateInstantiationDirectiveStatement: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationDirectiveStatement] << std::endl;
20803 0 : std::cout << "Memory pool size of SgTemplateInstantiationFunctionDecl: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationFunctionDecl] << std::endl;
20804 0 : std::cout << "Memory pool size of SgTemplateInstantiationMemberFunctionDecl: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationMemberFunctionDecl] << std::endl;
20805 0 : std::cout << "Memory pool size of SgTemplateInstantiationTypedefDeclaration: " << listOfMemoryPoolSizes[V_SgTemplateInstantiationTypedefDeclaration] << std::endl;
20806 0 : std::cout << "Memory pool size of SgTemplateParameter: " << listOfMemoryPoolSizes[V_SgTemplateParameter] << std::endl;
20807 0 : std::cout << "Memory pool size of SgTemplateParameterVal: " << listOfMemoryPoolSizes[V_SgTemplateParameterVal] << std::endl;
20808 0 : std::cout << "Memory pool size of SgTemplateParameterList: " << listOfMemoryPoolSizes[V_SgTemplateParameterList] << std::endl;
20809 0 : std::cout << "Memory pool size of SgTemplateSymbol: " << listOfMemoryPoolSizes[V_SgTemplateSymbol] << std::endl;
20810 0 : std::cout << "Memory pool size of SgTemplateType: " << listOfMemoryPoolSizes[V_SgTemplateType] << std::endl;
20811 0 : std::cout << "Memory pool size of SgThisExp: " << listOfMemoryPoolSizes[V_SgThisExp] << std::endl;
20812 0 : std::cout << "Memory pool size of SgTypeTraitBuiltinOperator: " << listOfMemoryPoolSizes[V_SgTypeTraitBuiltinOperator] << std::endl;
20813 0 : std::cout << "Memory pool size of SgSuperExp: " << listOfMemoryPoolSizes[V_SgSuperExp] << std::endl;
20814 0 : std::cout << "Memory pool size of SgThrowOp: " << listOfMemoryPoolSizes[V_SgThrowOp] << std::endl;
20815 0 : std::cout << "Memory pool size of SgToken: " << listOfMemoryPoolSizes[V_SgToken] << std::endl;
20816 0 : std::cout << "Memory pool size of SgTryStmt: " << listOfMemoryPoolSizes[V_SgTryStmt] << std::endl;
20817 0 : std::cout << "Memory pool size of SgTupleExp: " << listOfMemoryPoolSizes[V_SgTupleExp] << std::endl;
20818 0 : std::cout << "Memory pool size of SgType: " << listOfMemoryPoolSizes[V_SgType] << std::endl;
20819 0 : std::cout << "Memory pool size of SgTypeBool: " << listOfMemoryPoolSizes[V_SgTypeBool] << std::endl;
20820 0 : std::cout << "Memory pool size of SgTypeChar: " << listOfMemoryPoolSizes[V_SgTypeChar] << std::endl;
20821 0 : std::cout << "Memory pool size of SgTypeChar16: " << listOfMemoryPoolSizes[V_SgTypeChar16] << std::endl;
20822 0 : std::cout << "Memory pool size of SgTypeChar32: " << listOfMemoryPoolSizes[V_SgTypeChar32] << std::endl;
20823 0 : std::cout << "Memory pool size of SgTypeComplex: " << listOfMemoryPoolSizes[V_SgTypeComplex] << std::endl;
20824 0 : std::cout << "Memory pool size of SgTypeDefault: " << listOfMemoryPoolSizes[V_SgTypeDefault] << std::endl;
20825 0 : std::cout << "Memory pool size of SgTypeExpression: " << listOfMemoryPoolSizes[V_SgTypeExpression] << std::endl;
20826 0 : std::cout << "Memory pool size of SgTypeLabel: " << listOfMemoryPoolSizes[V_SgTypeLabel] << std::endl;
20827 0 : std::cout << "Memory pool size of SgTypeDouble: " << listOfMemoryPoolSizes[V_SgTypeDouble] << std::endl;
20828 0 : std::cout << "Memory pool size of SgTypeEllipse: " << listOfMemoryPoolSizes[V_SgTypeEllipse] << std::endl;
20829 0 : std::cout << "Memory pool size of SgTypeFixed: " << listOfMemoryPoolSizes[V_SgTypeFixed] << std::endl;
20830 0 : std::cout << "Memory pool size of SgTypeFloat: " << listOfMemoryPoolSizes[V_SgTypeFloat] << std::endl;
20831 0 : std::cout << "Memory pool size of SgTypeFloat128: " << listOfMemoryPoolSizes[V_SgTypeFloat128] << std::endl;
20832 0 : std::cout << "Memory pool size of SgTypeFloat80: " << listOfMemoryPoolSizes[V_SgTypeFloat80] << std::endl;
20833 0 : std::cout << "Memory pool size of SgTypeGlobalVoid: " << listOfMemoryPoolSizes[V_SgTypeGlobalVoid] << std::endl;
20834 0 : std::cout << "Memory pool size of SgTypeIdOp: " << listOfMemoryPoolSizes[V_SgTypeIdOp] << std::endl;
20835 0 : std::cout << "Memory pool size of SgTypeImaginary: " << listOfMemoryPoolSizes[V_SgTypeImaginary] << std::endl;
20836 0 : std::cout << "Memory pool size of SgTypeInt: " << listOfMemoryPoolSizes[V_SgTypeInt] << std::endl;
20837 0 : std::cout << "Memory pool size of SgTypeLong: " << listOfMemoryPoolSizes[V_SgTypeLong] << std::endl;
20838 0 : std::cout << "Memory pool size of SgTypeLongDouble: " << listOfMemoryPoolSizes[V_SgTypeLongDouble] << std::endl;
20839 0 : std::cout << "Memory pool size of SgTypeLongLong: " << listOfMemoryPoolSizes[V_SgTypeLongLong] << std::endl;
20840 0 : std::cout << "Memory pool size of SgTypeModifier: " << listOfMemoryPoolSizes[V_SgTypeModifier] << std::endl;
20841 0 : std::cout << "Memory pool size of SgTypeMatrix: " << listOfMemoryPoolSizes[V_SgTypeMatrix] << std::endl;
20842 0 : std::cout << "Memory pool size of SgTypeTuple: " << listOfMemoryPoolSizes[V_SgTypeTuple] << std::endl;
20843 0 : std::cout << "Memory pool size of SgTypeNullptr: " << listOfMemoryPoolSizes[V_SgTypeNullptr] << std::endl;
20844 0 : std::cout << "Memory pool size of SgTypeOfType: " << listOfMemoryPoolSizes[V_SgTypeOfType] << std::endl;
20845 0 : std::cout << "Memory pool size of SgTypeShort: " << listOfMemoryPoolSizes[V_SgTypeShort] << std::endl;
20846 0 : std::cout << "Memory pool size of SgTypeSigned128bitInteger: " << listOfMemoryPoolSizes[V_SgTypeSigned128bitInteger] << std::endl;
20847 0 : std::cout << "Memory pool size of SgTypeSignedChar: " << listOfMemoryPoolSizes[V_SgTypeSignedChar] << std::endl;
20848 0 : std::cout << "Memory pool size of SgTypeSignedInt: " << listOfMemoryPoolSizes[V_SgTypeSignedInt] << std::endl;
20849 0 : std::cout << "Memory pool size of SgTypeSignedLong: " << listOfMemoryPoolSizes[V_SgTypeSignedLong] << std::endl;
20850 0 : std::cout << "Memory pool size of SgTypeSignedLongLong: " << listOfMemoryPoolSizes[V_SgTypeSignedLongLong] << std::endl;
20851 0 : std::cout << "Memory pool size of SgTypeSignedShort: " << listOfMemoryPoolSizes[V_SgTypeSignedShort] << std::endl;
20852 0 : std::cout << "Memory pool size of SgTypeString: " << listOfMemoryPoolSizes[V_SgTypeString] << std::endl;
20853 0 : std::cout << "Memory pool size of SgTypeUnknown: " << listOfMemoryPoolSizes[V_SgTypeUnknown] << std::endl;
20854 0 : std::cout << "Memory pool size of SgTypeUnsigned128bitInteger: " << listOfMemoryPoolSizes[V_SgTypeUnsigned128bitInteger] << std::endl;
20855 0 : std::cout << "Memory pool size of SgTypeUnsignedChar: " << listOfMemoryPoolSizes[V_SgTypeUnsignedChar] << std::endl;
20856 0 : std::cout << "Memory pool size of SgTypeUnsignedInt: " << listOfMemoryPoolSizes[V_SgTypeUnsignedInt] << std::endl;
20857 0 : std::cout << "Memory pool size of SgTypeUnsignedLong: " << listOfMemoryPoolSizes[V_SgTypeUnsignedLong] << std::endl;
20858 0 : std::cout << "Memory pool size of SgTypeUnsignedLongLong: " << listOfMemoryPoolSizes[V_SgTypeUnsignedLongLong] << std::endl;
20859 0 : std::cout << "Memory pool size of SgTypeUnsignedShort: " << listOfMemoryPoolSizes[V_SgTypeUnsignedShort] << std::endl;
20860 0 : std::cout << "Memory pool size of SgTypeVoid: " << listOfMemoryPoolSizes[V_SgTypeVoid] << std::endl;
20861 0 : std::cout << "Memory pool size of SgTypeWchar: " << listOfMemoryPoolSizes[V_SgTypeWchar] << std::endl;
20862 0 : std::cout << "Memory pool size of SgTypedefDeclaration: " << listOfMemoryPoolSizes[V_SgTypedefDeclaration] << std::endl;
20863 0 : std::cout << "Memory pool size of SgTypedefSeq: " << listOfMemoryPoolSizes[V_SgTypedefSeq] << std::endl;
20864 0 : std::cout << "Memory pool size of SgTypedefSymbol: " << listOfMemoryPoolSizes[V_SgTypedefSymbol] << std::endl;
20865 0 : std::cout << "Memory pool size of SgTypedefType: " << listOfMemoryPoolSizes[V_SgTypedefType] << std::endl;
20866 0 : std::cout << "Memory pool size of SgUPC_AccessModifier: " << listOfMemoryPoolSizes[V_SgUPC_AccessModifier] << std::endl;
20867 0 : std::cout << "Memory pool size of SgUnaryAddOp: " << listOfMemoryPoolSizes[V_SgUnaryAddOp] << std::endl;
20868 0 : std::cout << "Memory pool size of SgUnaryOp: " << listOfMemoryPoolSizes[V_SgUnaryOp] << std::endl;
20869 0 : std::cout << "Memory pool size of SgUndefDirectiveStatement: " << listOfMemoryPoolSizes[V_SgUndefDirectiveStatement] << std::endl;
20870 0 : std::cout << "Memory pool size of SgUndirectedGraphEdge: " << listOfMemoryPoolSizes[V_SgUndirectedGraphEdge] << std::endl;
20871 0 : std::cout << "Memory pool size of SgUnknownArrayOrFunctionReference: " << listOfMemoryPoolSizes[V_SgUnknownArrayOrFunctionReference] << std::endl;
20872 0 : std::cout << "Memory pool size of SgUnknownFile: " << listOfMemoryPoolSizes[V_SgUnknownFile] << std::endl;
20873 0 : std::cout << "Memory pool size of SgUnparse_Info: " << listOfMemoryPoolSizes[V_SgUnparse_Info] << std::endl;
20874 0 : std::cout << "Memory pool size of SgUnsignedCharVal: " << listOfMemoryPoolSizes[V_SgUnsignedCharVal] << std::endl;
20875 0 : std::cout << "Memory pool size of SgUnsignedIntVal: " << listOfMemoryPoolSizes[V_SgUnsignedIntVal] << std::endl;
20876 0 : std::cout << "Memory pool size of SgUnsignedLongLongIntVal: " << listOfMemoryPoolSizes[V_SgUnsignedLongLongIntVal] << std::endl;
20877 0 : std::cout << "Memory pool size of SgUnsignedLongVal: " << listOfMemoryPoolSizes[V_SgUnsignedLongVal] << std::endl;
20878 0 : std::cout << "Memory pool size of SgUnsignedShortVal: " << listOfMemoryPoolSizes[V_SgUnsignedShortVal] << std::endl;
20879 0 : std::cout << "Memory pool size of SgUpcBarrierStatement: " << listOfMemoryPoolSizes[V_SgUpcBarrierStatement] << std::endl;
20880 0 : std::cout << "Memory pool size of SgUpcBlocksizeofExpression: " << listOfMemoryPoolSizes[V_SgUpcBlocksizeofExpression] << std::endl;
20881 0 : std::cout << "Memory pool size of SgUpcElemsizeofExpression: " << listOfMemoryPoolSizes[V_SgUpcElemsizeofExpression] << std::endl;
20882 0 : std::cout << "Memory pool size of SgUpcFenceStatement: " << listOfMemoryPoolSizes[V_SgUpcFenceStatement] << std::endl;
20883 0 : std::cout << "Memory pool size of SgUpcForAllStatement: " << listOfMemoryPoolSizes[V_SgUpcForAllStatement] << std::endl;
20884 0 : std::cout << "Memory pool size of SgUpcLocalsizeofExpression: " << listOfMemoryPoolSizes[V_SgUpcLocalsizeofExpression] << std::endl;
20885 0 : std::cout << "Memory pool size of SgUpcMythread: " << listOfMemoryPoolSizes[V_SgUpcMythread] << std::endl;
20886 0 : std::cout << "Memory pool size of SgUpcNotifyStatement: " << listOfMemoryPoolSizes[V_SgUpcNotifyStatement] << std::endl;
20887 0 : std::cout << "Memory pool size of SgUpcThreads: " << listOfMemoryPoolSizes[V_SgUpcThreads] << std::endl;
20888 0 : std::cout << "Memory pool size of SgUpcWaitStatement: " << listOfMemoryPoolSizes[V_SgUpcWaitStatement] << std::endl;
20889 0 : std::cout << "Memory pool size of SgUseStatement: " << listOfMemoryPoolSizes[V_SgUseStatement] << std::endl;
20890 0 : std::cout << "Memory pool size of SgUserDefinedBinaryOp: " << listOfMemoryPoolSizes[V_SgUserDefinedBinaryOp] << std::endl;
20891 0 : std::cout << "Memory pool size of SgUserDefinedUnaryOp: " << listOfMemoryPoolSizes[V_SgUserDefinedUnaryOp] << std::endl;
20892 0 : std::cout << "Memory pool size of SgUsingDeclarationStatement: " << listOfMemoryPoolSizes[V_SgUsingDeclarationStatement] << std::endl;
20893 0 : std::cout << "Memory pool size of SgUsingDirectiveStatement: " << listOfMemoryPoolSizes[V_SgUsingDirectiveStatement] << std::endl;
20894 0 : std::cout << "Memory pool size of SgValueExp: " << listOfMemoryPoolSizes[V_SgValueExp] << std::endl;
20895 0 : std::cout << "Memory pool size of SgVarArgCopyOp: " << listOfMemoryPoolSizes[V_SgVarArgCopyOp] << std::endl;
20896 0 : std::cout << "Memory pool size of SgVarArgEndOp: " << listOfMemoryPoolSizes[V_SgVarArgEndOp] << std::endl;
20897 0 : std::cout << "Memory pool size of SgVarArgOp: " << listOfMemoryPoolSizes[V_SgVarArgOp] << std::endl;
20898 0 : std::cout << "Memory pool size of SgVarArgStartOneOperandOp: " << listOfMemoryPoolSizes[V_SgVarArgStartOneOperandOp] << std::endl;
20899 0 : std::cout << "Memory pool size of SgVarArgStartOp: " << listOfMemoryPoolSizes[V_SgVarArgStartOp] << std::endl;
20900 0 : std::cout << "Memory pool size of SgVarRefExp: " << listOfMemoryPoolSizes[V_SgVarRefExp] << std::endl;
20901 0 : std::cout << "Memory pool size of SgVariableDeclaration: " << listOfMemoryPoolSizes[V_SgVariableDeclaration] << std::endl;
20902 0 : std::cout << "Memory pool size of SgVariableDefinition: " << listOfMemoryPoolSizes[V_SgVariableDefinition] << std::endl;
20903 0 : std::cout << "Memory pool size of SgVariableSymbol: " << listOfMemoryPoolSizes[V_SgVariableSymbol] << std::endl;
20904 0 : std::cout << "Memory pool size of SgVariantExpression: " << listOfMemoryPoolSizes[V_SgVariantExpression] << std::endl;
20905 0 : std::cout << "Memory pool size of SgVariantStatement: " << listOfMemoryPoolSizes[V_SgVariantStatement] << std::endl;
20906 0 : std::cout << "Memory pool size of SgVoidVal: " << listOfMemoryPoolSizes[V_SgVoidVal] << std::endl;
20907 0 : std::cout << "Memory pool size of SgWaitStatement: " << listOfMemoryPoolSizes[V_SgWaitStatement] << std::endl;
20908 0 : std::cout << "Memory pool size of SgWarningDirectiveStatement: " << listOfMemoryPoolSizes[V_SgWarningDirectiveStatement] << std::endl;
20909 0 : std::cout << "Memory pool size of SgWithStatement: " << listOfMemoryPoolSizes[V_SgWithStatement] << std::endl;
20910 0 : std::cout << "Memory pool size of SgWcharVal: " << listOfMemoryPoolSizes[V_SgWcharVal] << std::endl;
20911 0 : std::cout << "Memory pool size of SgWhereStatement: " << listOfMemoryPoolSizes[V_SgWhereStatement] << std::endl;
20912 0 : std::cout << "Memory pool size of SgWhileStmt: " << listOfMemoryPoolSizes[V_SgWhileStmt] << std::endl;
20913 0 : std::cout << "Memory pool size of SgWriteStatement: " << listOfMemoryPoolSizes[V_SgWriteStatement] << std::endl;
20914 0 : std::cout << "Memory pool size of SgXorAssignOp: " << listOfMemoryPoolSizes[V_SgXorAssignOp] << std::endl;
20915 0 : std::cout << "Memory pool size of SgYieldExpression: " << listOfMemoryPoolSizes[V_SgYieldExpression] << std::endl;
20916 0 : std::cout << "Memory pool size of Sg_File_Info: " << listOfMemoryPoolSizes[V_Sg_File_Info] << std::endl;
20917 0 : std::cout << "Memory pool size of SgTypeCAFTeam: " << listOfMemoryPoolSizes[V_SgTypeCAFTeam] << std::endl;
20918 0 : std::cout << "Memory pool size of SgCAFWithTeamStatement: " << listOfMemoryPoolSizes[V_SgCAFWithTeamStatement] << std::endl;
20919 0 : std::cout << "Memory pool size of SgCAFCoExpression: " << listOfMemoryPoolSizes[V_SgCAFCoExpression] << std::endl;
20920 0 : std::cout << "Memory pool size of SgCallExpression: " << listOfMemoryPoolSizes[V_SgCallExpression] << std::endl;
20921 0 : std::cout << "Memory pool size of SgTypeCrayPointer: " << listOfMemoryPoolSizes[V_SgTypeCrayPointer] << std::endl;
20922 0 : std::cout << "Memory pool size of SgClassExp: " << listOfMemoryPoolSizes[V_SgClassExp] << std::endl;
20923 :
20924 : /* #line 467 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
20925 0 : std::cout << " Total number of IR nodes in contained in the memory pools: "
20926 0 : << listOfMemoryPoolSizes[totalNumberOfIRNodes] << std::endl << std::endl;
20927 0 : return;
20928 : }
20929 :
20930 :
20931 : void
20932 0 : AST_FILE_IO::printListOfPoolSizesOfAst (int index)
20933 : {
20934 0 : std::cout << "Memory pool size of SgAccessModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAccessModifier) << std::endl;
20935 0 : std::cout << "Memory pool size of SgActualArgumentExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgActualArgumentExpression) << std::endl;
20936 0 : std::cout << "Memory pool size of SgAddOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAddOp) << std::endl;
20937 0 : std::cout << "Memory pool size of SgAddressOfOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAddressOfOp) << std::endl;
20938 0 : std::cout << "Memory pool size of SgAggregateInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAggregateInitializer) << std::endl;
20939 0 : std::cout << "Memory pool size of SgAliasSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAliasSymbol) << std::endl;
20940 0 : std::cout << "Memory pool size of SgAllocateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAllocateStatement) << std::endl;
20941 0 : std::cout << "Memory pool size of SgAndAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAndAssignOp) << std::endl;
20942 0 : std::cout << "Memory pool size of SgAndOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAndOp) << std::endl;
20943 0 : std::cout << "Memory pool size of SgArithmeticIfStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgArithmeticIfStatement) << std::endl;
20944 0 : std::cout << "Memory pool size of SgArrayType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgArrayType) << std::endl;
20945 0 : std::cout << "Memory pool size of SgArrowExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgArrowExp) << std::endl;
20946 0 : std::cout << "Memory pool size of SgArrowStarOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgArrowStarOp) << std::endl;
20947 0 : std::cout << "Memory pool size of SgAsmOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAsmOp) << std::endl;
20948 0 : std::cout << "Memory pool size of SgAsmStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAsmStmt) << std::endl;
20949 0 : std::cout << "Memory pool size of SgAssertStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssertStmt) << std::endl;
20950 0 : std::cout << "Memory pool size of SgAssignInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssignInitializer) << std::endl;
20951 0 : std::cout << "Memory pool size of SgAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssignOp) << std::endl;
20952 0 : std::cout << "Memory pool size of SgAssignStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssignStatement) << std::endl;
20953 0 : std::cout << "Memory pool size of SgAssignedGotoStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssignedGotoStatement) << std::endl;
20954 0 : std::cout << "Memory pool size of SgAssociateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAssociateStatement) << std::endl;
20955 0 : std::cout << "Memory pool size of SgAsteriskShapeExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAsteriskShapeExp) << std::endl;
20956 0 : std::cout << "Memory pool size of SgAttribute: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAttribute) << std::endl;
20957 0 : std::cout << "Memory pool size of SgAttributeSpecificationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAttributeSpecificationStatement) << std::endl;
20958 0 : std::cout << "Memory pool size of SgAutoType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAutoType) << std::endl;
20959 0 : std::cout << "Memory pool size of SgAwaitExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAwaitExpression) << std::endl;
20960 0 : std::cout << "Memory pool size of SgBackspaceStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBackspaceStatement) << std::endl;
20961 0 : std::cout << "Memory pool size of SgBaseClass: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBaseClass) << std::endl;
20962 0 : std::cout << "Memory pool size of SgExpBaseClass: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExpBaseClass) << std::endl;
20963 0 : std::cout << "Memory pool size of SgBaseClassModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBaseClassModifier) << std::endl;
20964 0 : std::cout << "Memory pool size of SgBasicBlock: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBasicBlock) << std::endl;
20965 0 : std::cout << "Memory pool size of SgBidirectionalGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBidirectionalGraph) << std::endl;
20966 0 : std::cout << "Memory pool size of SgBinaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBinaryOp) << std::endl;
20967 0 : std::cout << "Memory pool size of SgBitAndOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitAndOp) << std::endl;
20968 0 : std::cout << "Memory pool size of SgBitAttribute: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitAttribute) << std::endl;
20969 0 : std::cout << "Memory pool size of SgBitComplementOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitComplementOp) << std::endl;
20970 0 : std::cout << "Memory pool size of SgBitEqvOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitEqvOp) << std::endl;
20971 0 : std::cout << "Memory pool size of SgBitOrOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitOrOp) << std::endl;
20972 0 : std::cout << "Memory pool size of SgBitXorOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBitXorOp) << std::endl;
20973 0 : std::cout << "Memory pool size of SgBlockDataStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBlockDataStatement) << std::endl;
20974 0 : std::cout << "Memory pool size of SgBoolValExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBoolValExp) << std::endl;
20975 0 : std::cout << "Memory pool size of SgBreakStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBreakStmt) << std::endl;
20976 0 : std::cout << "Memory pool size of SgBracedInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgBracedInitializer) << std::endl;
20977 0 : std::cout << "Memory pool size of SgC_PreprocessorDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgC_PreprocessorDirectiveStatement) << std::endl;
20978 0 : std::cout << "Memory pool size of SgCaseOptionStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCaseOptionStmt) << std::endl;
20979 0 : std::cout << "Memory pool size of SgCastExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCastExp) << std::endl;
20980 0 : std::cout << "Memory pool size of SgCatchOptionStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCatchOptionStmt) << std::endl;
20981 0 : std::cout << "Memory pool size of SgCatchStatementSeq: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCatchStatementSeq) << std::endl;
20982 0 : std::cout << "Memory pool size of SgCharVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCharVal) << std::endl;
20983 0 : std::cout << "Memory pool size of SgChar16Val: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgChar16Val) << std::endl;
20984 0 : std::cout << "Memory pool size of SgChar32Val: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgChar32Val) << std::endl;
20985 0 : std::cout << "Memory pool size of SgChooseExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgChooseExpression) << std::endl;
20986 0 : std::cout << "Memory pool size of SgClassDecl_attr: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassDecl_attr) << std::endl;
20987 0 : std::cout << "Memory pool size of SgClassDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassDeclaration) << std::endl;
20988 0 : std::cout << "Memory pool size of SgClassDefinition: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassDefinition) << std::endl;
20989 0 : std::cout << "Memory pool size of SgClassNameRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassNameRefExp) << std::endl;
20990 0 : std::cout << "Memory pool size of SgClassSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassSymbol) << std::endl;
20991 0 : std::cout << "Memory pool size of SgClassType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassType) << std::endl;
20992 0 : std::cout << "Memory pool size of SgClinkageDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClinkageDeclarationStatement) << std::endl;
20993 0 : std::cout << "Memory pool size of SgClinkageEndStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClinkageEndStatement) << std::endl;
20994 0 : std::cout << "Memory pool size of SgClinkageStartStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClinkageStartStatement) << std::endl;
20995 0 : std::cout << "Memory pool size of SgCloseStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCloseStatement) << std::endl;
20996 0 : std::cout << "Memory pool size of SgColonShapeExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgColonShapeExp) << std::endl;
20997 0 : std::cout << "Memory pool size of SgCommaOpExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCommaOpExp) << std::endl;
20998 0 : std::cout << "Memory pool size of SgCommonBlock: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCommonBlock) << std::endl;
20999 0 : std::cout << "Memory pool size of SgCommonBlockObject: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCommonBlockObject) << std::endl;
21000 0 : std::cout << "Memory pool size of SgCommonSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCommonSymbol) << std::endl;
21001 0 : std::cout << "Memory pool size of SgComplexVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgComplexVal) << std::endl;
21002 0 : std::cout << "Memory pool size of SgComprehension: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgComprehension) << std::endl;
21003 0 : std::cout << "Memory pool size of SgCompoundAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCompoundAssignOp) << std::endl;
21004 0 : std::cout << "Memory pool size of SgCompoundInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCompoundInitializer) << std::endl;
21005 0 : std::cout << "Memory pool size of SgCompoundLiteralExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCompoundLiteralExp) << std::endl;
21006 0 : std::cout << "Memory pool size of SgComputedGotoStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgComputedGotoStatement) << std::endl;
21007 0 : std::cout << "Memory pool size of SgConcatenationOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgConcatenationOp) << std::endl;
21008 0 : std::cout << "Memory pool size of SgConditionalExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgConditionalExp) << std::endl;
21009 0 : std::cout << "Memory pool size of SgConjugateOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgConjugateOp) << std::endl;
21010 0 : std::cout << "Memory pool size of SgConstVolatileModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgConstVolatileModifier) << std::endl;
21011 0 : std::cout << "Memory pool size of SgConstructorInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgConstructorInitializer) << std::endl;
21012 0 : std::cout << "Memory pool size of SgContainsStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgContainsStatement) << std::endl;
21013 0 : std::cout << "Memory pool size of SgContinueStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgContinueStmt) << std::endl;
21014 0 : std::cout << "Memory pool size of SgCtorInitializerList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCtorInitializerList) << std::endl;
21015 0 : std::cout << "Memory pool size of SgDataStatementGroup: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDataStatementGroup) << std::endl;
21016 0 : std::cout << "Memory pool size of SgDataStatementObject: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDataStatementObject) << std::endl;
21017 0 : std::cout << "Memory pool size of SgDataStatementValue: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDataStatementValue) << std::endl;
21018 0 : std::cout << "Memory pool size of SgDeadIfDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeadIfDirectiveStatement) << std::endl;
21019 0 : std::cout << "Memory pool size of SgDeallocateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeallocateStatement) << std::endl;
21020 0 : std::cout << "Memory pool size of SgDeclarationModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeclarationModifier) << std::endl;
21021 0 : std::cout << "Memory pool size of SgDeclarationScope: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeclarationScope) << std::endl;
21022 0 : std::cout << "Memory pool size of SgDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeclarationStatement) << std::endl;
21023 0 : std::cout << "Memory pool size of SgDeclType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeclType) << std::endl;
21024 0 : std::cout << "Memory pool size of SgDefaultOptionStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDefaultOptionStmt) << std::endl;
21025 0 : std::cout << "Memory pool size of SgDefaultSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDefaultSymbol) << std::endl;
21026 0 : std::cout << "Memory pool size of SgDefineDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDefineDirectiveStatement) << std::endl;
21027 0 : std::cout << "Memory pool size of SgDeleteExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDeleteExp) << std::endl;
21028 0 : std::cout << "Memory pool size of SgDerivedTypeStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDerivedTypeStatement) << std::endl;
21029 0 : std::cout << "Memory pool size of SgDesignatedInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDesignatedInitializer) << std::endl;
21030 0 : std::cout << "Memory pool size of SgDictionaryComprehension: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDictionaryComprehension) << std::endl;
21031 0 : std::cout << "Memory pool size of SgDictionaryExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDictionaryExp) << std::endl;
21032 0 : std::cout << "Memory pool size of SgDimensionObject: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDimensionObject) << std::endl;
21033 0 : std::cout << "Memory pool size of SgDirectedGraphEdge: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDirectedGraphEdge) << std::endl;
21034 0 : std::cout << "Memory pool size of SgDirectory: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDirectory) << std::endl;
21035 0 : std::cout << "Memory pool size of SgDirectoryList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDirectoryList) << std::endl;
21036 0 : std::cout << "Memory pool size of SgDivAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDivAssignOp) << std::endl;
21037 0 : std::cout << "Memory pool size of SgDivideOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDivideOp) << std::endl;
21038 0 : std::cout << "Memory pool size of SgDoWhileStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDoWhileStmt) << std::endl;
21039 0 : std::cout << "Memory pool size of SgDotExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDotExp) << std::endl;
21040 0 : std::cout << "Memory pool size of SgDotStarOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDotStarOp) << std::endl;
21041 0 : std::cout << "Memory pool size of SgDoubleVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgDoubleVal) << std::endl;
21042 0 : std::cout << "Memory pool size of SgElaboratedTypeModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElaboratedTypeModifier) << std::endl;
21043 0 : std::cout << "Memory pool size of SgElementwiseOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseOp) << std::endl;
21044 0 : std::cout << "Memory pool size of SgElementwiseAddOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseAddOp) << std::endl;
21045 0 : std::cout << "Memory pool size of SgElementwiseDivideOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseDivideOp) << std::endl;
21046 0 : std::cout << "Memory pool size of SgElementwiseLeftDivideOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseLeftDivideOp) << std::endl;
21047 0 : std::cout << "Memory pool size of SgElementwiseMultiplyOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseMultiplyOp) << std::endl;
21048 0 : std::cout << "Memory pool size of SgElementwisePowerOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwisePowerOp) << std::endl;
21049 0 : std::cout << "Memory pool size of SgElementwiseSubtractOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElementwiseSubtractOp) << std::endl;
21050 0 : std::cout << "Memory pool size of SgElseDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElseDirectiveStatement) << std::endl;
21051 0 : std::cout << "Memory pool size of SgElseWhereStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElseWhereStatement) << std::endl;
21052 0 : std::cout << "Memory pool size of SgElseifDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgElseifDirectiveStatement) << std::endl;
21053 0 : std::cout << "Memory pool size of SgEmptyDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEmptyDeclaration) << std::endl;
21054 0 : std::cout << "Memory pool size of SgEmptyDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEmptyDirectiveStatement) << std::endl;
21055 0 : std::cout << "Memory pool size of SgEndfileStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEndfileStatement) << std::endl;
21056 0 : std::cout << "Memory pool size of SgEndifDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEndifDirectiveStatement) << std::endl;
21057 0 : std::cout << "Memory pool size of SgEntryStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEntryStatement) << std::endl;
21058 0 : std::cout << "Memory pool size of SgEnumDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEnumDeclaration) << std::endl;
21059 0 : std::cout << "Memory pool size of SgEnumFieldSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEnumFieldSymbol) << std::endl;
21060 0 : std::cout << "Memory pool size of SgEnumSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEnumSymbol) << std::endl;
21061 0 : std::cout << "Memory pool size of SgEnumType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEnumType) << std::endl;
21062 0 : std::cout << "Memory pool size of SgEnumVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEnumVal) << std::endl;
21063 0 : std::cout << "Memory pool size of SgEqualityOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEqualityOp) << std::endl;
21064 0 : std::cout << "Memory pool size of SgEquivalenceStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgEquivalenceStatement) << std::endl;
21065 0 : std::cout << "Memory pool size of SgErrorDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgErrorDirectiveStatement) << std::endl;
21066 0 : std::cout << "Memory pool size of SgExecStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExecStatement) << std::endl;
21067 0 : std::cout << "Memory pool size of SgExponentiationOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExponentiationOp) << std::endl;
21068 0 : std::cout << "Memory pool size of SgExponentiationAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExponentiationAssignOp) << std::endl;
21069 0 : std::cout << "Memory pool size of SgExprListExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExprListExp) << std::endl;
21070 0 : std::cout << "Memory pool size of SgExprStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExprStatement) << std::endl;
21071 0 : std::cout << "Memory pool size of SgExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExpression) << std::endl;
21072 0 : std::cout << "Memory pool size of SgExpressionRoot: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgExpressionRoot) << std::endl;
21073 0 : std::cout << "Memory pool size of SgFile: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFile) << std::endl;
21074 0 : std::cout << "Memory pool size of SgFileList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFileList) << std::endl;
21075 0 : std::cout << "Memory pool size of SgFloatVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFloatVal) << std::endl;
21076 0 : std::cout << "Memory pool size of SgFloat128Val: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFloat128Val) << std::endl;
21077 0 : std::cout << "Memory pool size of SgFloat80Val: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFloat80Val) << std::endl;
21078 0 : std::cout << "Memory pool size of SgFoldExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFoldExpression) << std::endl;
21079 0 : std::cout << "Memory pool size of SgFlushStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFlushStatement) << std::endl;
21080 0 : std::cout << "Memory pool size of SgForAllStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgForAllStatement) << std::endl;
21081 0 : std::cout << "Memory pool size of SgForInitStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgForInitStatement) << std::endl;
21082 0 : std::cout << "Memory pool size of SgForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgForStatement) << std::endl;
21083 0 : std::cout << "Memory pool size of SgFormatItem: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFormatItem) << std::endl;
21084 0 : std::cout << "Memory pool size of SgFormatItemList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFormatItemList) << std::endl;
21085 0 : std::cout << "Memory pool size of SgFormatStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFormatStatement) << std::endl;
21086 0 : std::cout << "Memory pool size of SgFortranDo: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFortranDo) << std::endl;
21087 0 : std::cout << "Memory pool size of SgFortranIncludeLine: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFortranIncludeLine) << std::endl;
21088 0 : std::cout << "Memory pool size of SgFortranNonblockedDo: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFortranNonblockedDo) << std::endl;
21089 0 : std::cout << "Memory pool size of SgFuncDecl_attr: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFuncDecl_attr) << std::endl;
21090 0 : std::cout << "Memory pool size of SgFunctionCallExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionCallExp) << std::endl;
21091 0 : std::cout << "Memory pool size of SgFunctionDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionDeclaration) << std::endl;
21092 0 : std::cout << "Memory pool size of SgFunctionDefinition: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionDefinition) << std::endl;
21093 0 : std::cout << "Memory pool size of SgFunctionParameterScope: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionParameterScope) << std::endl;
21094 0 : std::cout << "Memory pool size of SgFunctionModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionModifier) << std::endl;
21095 0 : std::cout << "Memory pool size of SgFunctionParameterList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionParameterList) << std::endl;
21096 0 : std::cout << "Memory pool size of SgFunctionParameterRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionParameterRefExp) << std::endl;
21097 0 : std::cout << "Memory pool size of SgFunctionParameterTypeList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionParameterTypeList) << std::endl;
21098 0 : std::cout << "Memory pool size of SgFunctionRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionRefExp) << std::endl;
21099 0 : std::cout << "Memory pool size of SgFunctionSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionSymbol) << std::endl;
21100 0 : std::cout << "Memory pool size of SgFunctionType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionType) << std::endl;
21101 0 : std::cout << "Memory pool size of SgFunctionTypeSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionTypeSymbol) << std::endl;
21102 0 : std::cout << "Memory pool size of SgFunctionTypeTable: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgFunctionTypeTable) << std::endl;
21103 0 : std::cout << "Memory pool size of SgTypeTable: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeTable) << std::endl;
21104 0 : std::cout << "Memory pool size of SgGlobal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGlobal) << std::endl;
21105 0 : std::cout << "Memory pool size of SgGotoStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGotoStatement) << std::endl;
21106 0 : std::cout << "Memory pool size of SgGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGraph) << std::endl;
21107 0 : std::cout << "Memory pool size of SgGraphEdge: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGraphEdge) << std::endl;
21108 0 : std::cout << "Memory pool size of SgGraphEdgeList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGraphEdgeList) << std::endl;
21109 0 : std::cout << "Memory pool size of SgGraphNode: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGraphNode) << std::endl;
21110 0 : std::cout << "Memory pool size of SgGraphNodeList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGraphNodeList) << std::endl;
21111 0 : std::cout << "Memory pool size of SgGreaterOrEqualOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGreaterOrEqualOp) << std::endl;
21112 0 : std::cout << "Memory pool size of SgGreaterThanOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgGreaterThanOp) << std::endl;
21113 0 : std::cout << "Memory pool size of SgIOItemExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIOItemExpression) << std::endl;
21114 0 : std::cout << "Memory pool size of SgIOStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIOStatement) << std::endl;
21115 0 : std::cout << "Memory pool size of SgIdentDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIdentDirectiveStatement) << std::endl;
21116 0 : std::cout << "Memory pool size of SgIfDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIfDirectiveStatement) << std::endl;
21117 0 : std::cout << "Memory pool size of SgIfStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIfStmt) << std::endl;
21118 0 : std::cout << "Memory pool size of SgIfdefDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIfdefDirectiveStatement) << std::endl;
21119 0 : std::cout << "Memory pool size of SgIfndefDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIfndefDirectiveStatement) << std::endl;
21120 0 : std::cout << "Memory pool size of SgImageControlStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgImageControlStatement) << std::endl;
21121 0 : std::cout << "Memory pool size of SgImagPartOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgImagPartOp) << std::endl;
21122 0 : std::cout << "Memory pool size of SgImplicitStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgImplicitStatement) << std::endl;
21123 0 : std::cout << "Memory pool size of SgImpliedDo: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgImpliedDo) << std::endl;
21124 0 : std::cout << "Memory pool size of SgImportStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgImportStatement) << std::endl;
21125 0 : std::cout << "Memory pool size of SgIncidenceDirectedGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIncidenceDirectedGraph) << std::endl;
21126 0 : std::cout << "Memory pool size of SgIncidenceUndirectedGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIncidenceUndirectedGraph) << std::endl;
21127 0 : std::cout << "Memory pool size of SgIncludeDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIncludeDirectiveStatement) << std::endl;
21128 0 : std::cout << "Memory pool size of SgIncludeFile: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIncludeFile) << std::endl;
21129 0 : std::cout << "Memory pool size of SgIncludeNextDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIncludeNextDirectiveStatement) << std::endl;
21130 0 : std::cout << "Memory pool size of SgInitializedName: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInitializedName) << std::endl;
21131 0 : std::cout << "Memory pool size of SgInitializer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInitializer) << std::endl;
21132 0 : std::cout << "Memory pool size of SgInquireStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInquireStatement) << std::endl;
21133 0 : std::cout << "Memory pool size of SgIntKeyedBidirectionalGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIntKeyedBidirectionalGraph) << std::endl;
21134 0 : std::cout << "Memory pool size of SgIntVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIntVal) << std::endl;
21135 0 : std::cout << "Memory pool size of SgIntegerDivideOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIntegerDivideOp) << std::endl;
21136 0 : std::cout << "Memory pool size of SgIntegerDivideAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIntegerDivideAssignOp) << std::endl;
21137 0 : std::cout << "Memory pool size of SgInterfaceBody: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInterfaceBody) << std::endl;
21138 0 : std::cout << "Memory pool size of SgHeaderFileBody: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgHeaderFileBody) << std::endl;
21139 0 : std::cout << "Memory pool size of SgHeaderFileReport: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgHeaderFileReport) << std::endl;
21140 0 : std::cout << "Memory pool size of SgInterfaceStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInterfaceStatement) << std::endl;
21141 0 : std::cout << "Memory pool size of SgInterfaceSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgInterfaceSymbol) << std::endl;
21142 0 : std::cout << "Memory pool size of SgIntrinsicSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIntrinsicSymbol) << std::endl;
21143 0 : std::cout << "Memory pool size of SgIsOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIsOp) << std::endl;
21144 0 : std::cout << "Memory pool size of SgIsNotOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIsNotOp) << std::endl;
21145 0 : std::cout << "Memory pool size of SgIorAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgIorAssignOp) << std::endl;
21146 0 : std::cout << "Memory pool size of SgKeyDatumPair: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgKeyDatumPair) << std::endl;
21147 0 : std::cout << "Memory pool size of SgCudaKernelExecConfig: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCudaKernelExecConfig) << std::endl;
21148 0 : std::cout << "Memory pool size of SgCudaKernelCallExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCudaKernelCallExp) << std::endl;
21149 0 : std::cout << "Memory pool size of SgLabelRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLabelRefExp) << std::endl;
21150 0 : std::cout << "Memory pool size of SgLabelStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLabelStatement) << std::endl;
21151 0 : std::cout << "Memory pool size of SgLabelSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLabelSymbol) << std::endl;
21152 0 : std::cout << "Memory pool size of SgLambdaCapture: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLambdaCapture) << std::endl;
21153 0 : std::cout << "Memory pool size of SgLambdaCaptureList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLambdaCaptureList) << std::endl;
21154 0 : std::cout << "Memory pool size of SgLambdaExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLambdaExp) << std::endl;
21155 0 : std::cout << "Memory pool size of SgLambdaRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLambdaRefExp) << std::endl;
21156 0 : std::cout << "Memory pool size of SgLeftDivideOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLeftDivideOp) << std::endl;
21157 0 : std::cout << "Memory pool size of SgLessOrEqualOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLessOrEqualOp) << std::endl;
21158 0 : std::cout << "Memory pool size of SgLessThanOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLessThanOp) << std::endl;
21159 0 : std::cout << "Memory pool size of SgLineDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLineDirectiveStatement) << std::endl;
21160 0 : std::cout << "Memory pool size of SgLinemarkerDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLinemarkerDirectiveStatement) << std::endl;
21161 0 : std::cout << "Memory pool size of SgLinkageModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLinkageModifier) << std::endl;
21162 0 : std::cout << "Memory pool size of SgListComprehension: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgListComprehension) << std::endl;
21163 0 : std::cout << "Memory pool size of SgListExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgListExp) << std::endl;
21164 0 : std::cout << "Memory pool size of SgLocatedNode: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLocatedNode) << std::endl;
21165 0 : std::cout << "Memory pool size of SgLocatedNodeSupport: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLocatedNodeSupport) << std::endl;
21166 0 : std::cout << "Memory pool size of SgLongDoubleVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLongDoubleVal) << std::endl;
21167 0 : std::cout << "Memory pool size of SgLongIntVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLongIntVal) << std::endl;
21168 0 : std::cout << "Memory pool size of SgLongLongIntVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLongLongIntVal) << std::endl;
21169 0 : std::cout << "Memory pool size of SgLshiftAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLshiftAssignOp) << std::endl;
21170 0 : std::cout << "Memory pool size of SgLshiftOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLshiftOp) << std::endl;
21171 0 : std::cout << "Memory pool size of SgMagicColonExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMagicColonExp) << std::endl;
21172 0 : std::cout << "Memory pool size of SgMatrixExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMatrixExp) << std::endl;
21173 0 : std::cout << "Memory pool size of SgMatrixTransposeOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMatrixTransposeOp) << std::endl;
21174 0 : std::cout << "Memory pool size of SgMemberFunctionDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMemberFunctionDeclaration) << std::endl;
21175 0 : std::cout << "Memory pool size of SgMemberFunctionRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMemberFunctionRefExp) << std::endl;
21176 0 : std::cout << "Memory pool size of SgMemberFunctionSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMemberFunctionSymbol) << std::endl;
21177 0 : std::cout << "Memory pool size of SgMemberFunctionType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMemberFunctionType) << std::endl;
21178 0 : std::cout << "Memory pool size of SgMembershipOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMembershipOp) << std::endl;
21179 0 : std::cout << "Memory pool size of SgMicrosoftAttributeDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMicrosoftAttributeDeclaration) << std::endl;
21180 0 : std::cout << "Memory pool size of SgMinusAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMinusAssignOp) << std::endl;
21181 0 : std::cout << "Memory pool size of SgMinusMinusOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMinusMinusOp) << std::endl;
21182 0 : std::cout << "Memory pool size of SgMinusOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMinusOp) << std::endl;
21183 0 : std::cout << "Memory pool size of SgModAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModAssignOp) << std::endl;
21184 0 : std::cout << "Memory pool size of SgModOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModOp) << std::endl;
21185 0 : std::cout << "Memory pool size of SgModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModifier) << std::endl;
21186 0 : std::cout << "Memory pool size of SgModifierNodes: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModifierNodes) << std::endl;
21187 0 : std::cout << "Memory pool size of SgModifierType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModifierType) << std::endl;
21188 0 : std::cout << "Memory pool size of SgModuleStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModuleStatement) << std::endl;
21189 0 : std::cout << "Memory pool size of SgModuleSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgModuleSymbol) << std::endl;
21190 0 : std::cout << "Memory pool size of SgMultAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMultAssignOp) << std::endl;
21191 0 : std::cout << "Memory pool size of SgMultiplyOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgMultiplyOp) << std::endl;
21192 0 : std::cout << "Memory pool size of SgName: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgName) << std::endl;
21193 0 : std::cout << "Memory pool size of SgNameGroup: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNameGroup) << std::endl;
21194 0 : std::cout << "Memory pool size of SgNamedType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamedType) << std::endl;
21195 0 : std::cout << "Memory pool size of SgNamelistStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamelistStatement) << std::endl;
21196 0 : std::cout << "Memory pool size of SgNamespaceAliasDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamespaceAliasDeclarationStatement) << std::endl;
21197 0 : std::cout << "Memory pool size of SgNamespaceDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamespaceDeclarationStatement) << std::endl;
21198 0 : std::cout << "Memory pool size of SgNamespaceDefinitionStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamespaceDefinitionStatement) << std::endl;
21199 0 : std::cout << "Memory pool size of SgNamespaceSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNamespaceSymbol) << std::endl;
21200 0 : std::cout << "Memory pool size of SgNaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNaryOp) << std::endl;
21201 0 : std::cout << "Memory pool size of SgNaryBooleanOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNaryBooleanOp) << std::endl;
21202 0 : std::cout << "Memory pool size of SgNaryComparisonOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNaryComparisonOp) << std::endl;
21203 0 : std::cout << "Memory pool size of SgNewExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNewExp) << std::endl;
21204 0 : std::cout << "Memory pool size of SgNode: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNode) << std::endl;
21205 0 : std::cout << "Memory pool size of SgNoexceptOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNoexceptOp) << std::endl;
21206 0 : std::cout << "Memory pool size of SgNotEqualOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNotEqualOp) << std::endl;
21207 0 : std::cout << "Memory pool size of SgNotOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNotOp) << std::endl;
21208 0 : std::cout << "Memory pool size of SgNonMembershipOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonMembershipOp) << std::endl;
21209 0 : std::cout << "Memory pool size of SgNonrealDecl: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonrealDecl) << std::endl;
21210 0 : std::cout << "Memory pool size of SgNonrealRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonrealRefExp) << std::endl;
21211 0 : std::cout << "Memory pool size of SgNonrealSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonrealSymbol) << std::endl;
21212 0 : std::cout << "Memory pool size of SgNonrealType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonrealType) << std::endl;
21213 0 : std::cout << "Memory pool size of SgNonrealBaseClass: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNonrealBaseClass) << std::endl;
21214 0 : std::cout << "Memory pool size of SgNullExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNullExpression) << std::endl;
21215 0 : std::cout << "Memory pool size of SgNullptrValExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNullptrValExp) << std::endl;
21216 0 : std::cout << "Memory pool size of SgNullStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNullStatement) << std::endl;
21217 0 : std::cout << "Memory pool size of SgNullifyStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgNullifyStatement) << std::endl;
21218 0 : std::cout << "Memory pool size of SgOmpAtomicStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAtomicStatement) << std::endl;
21219 0 : std::cout << "Memory pool size of SgOmpBarrierStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpBarrierStatement) << std::endl;
21220 0 : std::cout << "Memory pool size of SgOmpCriticalStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCriticalStatement) << std::endl;
21221 0 : std::cout << "Memory pool size of SgUpirFieldBodyStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirFieldBodyStatement) << std::endl;
21222 0 : std::cout << "Memory pool size of SgUpirBodyStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirBodyStatement) << std::endl;
21223 0 : std::cout << "Memory pool size of SgUpirFieldStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirFieldStatement) << std::endl;
21224 0 : std::cout << "Memory pool size of SgOmpDoStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDoStatement) << std::endl;
21225 0 : std::cout << "Memory pool size of SgOmpFlushStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpFlushStatement) << std::endl;
21226 0 : std::cout << "Memory pool size of SgOmpAllocateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAllocateStatement) << std::endl;
21227 0 : std::cout << "Memory pool size of SgOmpDeclareSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDeclareSimdStatement) << std::endl;
21228 0 : std::cout << "Memory pool size of SgUpirWorksharingStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirWorksharingStatement) << std::endl;
21229 0 : std::cout << "Memory pool size of SgOmpForSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpForSimdStatement) << std::endl;
21230 0 : std::cout << "Memory pool size of SgOmpMasterStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMasterStatement) << std::endl;
21231 0 : std::cout << "Memory pool size of SgOmpTaskyieldStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskyieldStatement) << std::endl;
21232 0 : std::cout << "Memory pool size of SgOmpMetadirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMetadirectiveStatement) << std::endl;
21233 0 : std::cout << "Memory pool size of SgOmpOrderedStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpOrderedStatement) << std::endl;
21234 0 : std::cout << "Memory pool size of SgOmpOrderedDependStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpOrderedDependStatement) << std::endl;
21235 0 : std::cout << "Memory pool size of SgUpirSpmdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirSpmdStatement) << std::endl;
21236 0 : std::cout << "Memory pool size of SgOmpTeamsStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsStatement) << std::endl;
21237 0 : std::cout << "Memory pool size of SgOmpCancellationPointStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCancellationPointStatement) << std::endl;
21238 0 : std::cout << "Memory pool size of SgOmpDeclareMapperStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDeclareMapperStatement) << std::endl;
21239 0 : std::cout << "Memory pool size of SgOmpCancelStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCancelStatement) << std::endl;
21240 0 : std::cout << "Memory pool size of SgOmpTaskgroupStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskgroupStatement) << std::endl;
21241 0 : std::cout << "Memory pool size of SgOmpDepobjStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDepobjStatement) << std::endl;
21242 0 : std::cout << "Memory pool size of SgOmpDistributeStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDistributeStatement) << std::endl;
21243 0 : std::cout << "Memory pool size of SgOmpLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpLoopStatement) << std::endl;
21244 0 : std::cout << "Memory pool size of SgOmpScanStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpScanStatement) << std::endl;
21245 0 : std::cout << "Memory pool size of SgOmpTaskloopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskloopStatement) << std::endl;
21246 0 : std::cout << "Memory pool size of SgOmpTargetEnterDataStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetEnterDataStatement) << std::endl;
21247 0 : std::cout << "Memory pool size of SgOmpTargetExitDataStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetExitDataStatement) << std::endl;
21248 0 : std::cout << "Memory pool size of SgOmpSectionStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSectionStatement) << std::endl;
21249 0 : std::cout << "Memory pool size of SgOmpSectionsStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSectionsStatement) << std::endl;
21250 0 : std::cout << "Memory pool size of SgOmpSingleStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSingleStatement) << std::endl;
21251 0 : std::cout << "Memory pool size of SgOmpTaskStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskStatement) << std::endl;
21252 0 : std::cout << "Memory pool size of SgOmpTaskwaitStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskwaitStatement) << std::endl;
21253 0 : std::cout << "Memory pool size of SgOmpThreadprivateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpThreadprivateStatement) << std::endl;
21254 0 : std::cout << "Memory pool size of SgOmpWorkshareStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpWorkshareStatement) << std::endl;
21255 0 : std::cout << "Memory pool size of SgUpirTaskStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirTaskStatement) << std::endl;
21256 0 : std::cout << "Memory pool size of SgOmpTargetDataStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetDataStatement) << std::endl;
21257 0 : std::cout << "Memory pool size of SgOmpTargetParallelForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetParallelForStatement) << std::endl;
21258 0 : std::cout << "Memory pool size of SgOmpTargetUpdateStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetUpdateStatement) << std::endl;
21259 0 : std::cout << "Memory pool size of SgOmpRequiresStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpRequiresStatement) << std::endl;
21260 0 : std::cout << "Memory pool size of SgOmpTargetParallelStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetParallelStatement) << std::endl;
21261 0 : std::cout << "Memory pool size of SgOmpTargetParallelForSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetParallelForSimdStatement) << std::endl;
21262 0 : std::cout << "Memory pool size of SgOmpTargetParallelLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetParallelLoopStatement) << std::endl;
21263 0 : std::cout << "Memory pool size of SgOmpTargetSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetSimdStatement) << std::endl;
21264 0 : std::cout << "Memory pool size of SgOmpTargetTeamsStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsStatement) << std::endl;
21265 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsDistributeStatement) << std::endl;
21266 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsDistributeSimdStatement) << std::endl;
21267 0 : std::cout << "Memory pool size of SgOmpTargetTeamsLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsLoopStatement) << std::endl;
21268 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeParallelForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsDistributeParallelForStatement) << std::endl;
21269 0 : std::cout << "Memory pool size of SgOmpTargetTeamsDistributeParallelForSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTargetTeamsDistributeParallelForSimdStatement) << std::endl;
21270 0 : std::cout << "Memory pool size of SgOmpDistributeSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDistributeSimdStatement) << std::endl;
21271 0 : std::cout << "Memory pool size of SgOmpDistributeParallelForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDistributeParallelForStatement) << std::endl;
21272 0 : std::cout << "Memory pool size of SgOmpDistributeParallelForSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDistributeParallelForSimdStatement) << std::endl;
21273 0 : std::cout << "Memory pool size of SgOmpTaskloopSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskloopSimdStatement) << std::endl;
21274 0 : std::cout << "Memory pool size of SgOmpMasterTaskloopSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMasterTaskloopSimdStatement) << std::endl;
21275 0 : std::cout << "Memory pool size of SgOmpParallelMasterTaskloopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpParallelMasterTaskloopStatement) << std::endl;
21276 0 : std::cout << "Memory pool size of SgOmpParallelMasterTaskloopSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpParallelMasterTaskloopSimdStatement) << std::endl;
21277 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsDistributeStatement) << std::endl;
21278 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsDistributeSimdStatement) << std::endl;
21279 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeParallelForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsDistributeParallelForStatement) << std::endl;
21280 0 : std::cout << "Memory pool size of SgOmpTeamsDistributeParallelForSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsDistributeParallelForSimdStatement) << std::endl;
21281 0 : std::cout << "Memory pool size of SgOmpTeamsLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTeamsLoopStatement) << std::endl;
21282 0 : std::cout << "Memory pool size of SgOmpParallelLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpParallelLoopStatement) << std::endl;
21283 0 : std::cout << "Memory pool size of SgOmpParallelMasterStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpParallelMasterStatement) << std::endl;
21284 0 : std::cout << "Memory pool size of SgOmpMasterTaskloopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMasterTaskloopStatement) << std::endl;
21285 0 : std::cout << "Memory pool size of SgOmpUnrollStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUnrollStatement) << std::endl;
21286 0 : std::cout << "Memory pool size of SgOmpTileStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTileStatement) << std::endl;
21287 0 : std::cout << "Memory pool size of SgUpirSimdStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirSimdStatement) << std::endl;
21288 0 : std::cout << "Memory pool size of SgUpirBaseStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirBaseStatement) << std::endl;
21289 0 : std::cout << "Memory pool size of SgUpirLoopStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirLoopStatement) << std::endl;
21290 0 : std::cout << "Memory pool size of SgUpirLoopParallelStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirLoopParallelStatement) << std::endl;
21291 0 : std::cout << "Memory pool size of SgUpirSyncStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirSyncStatement) << std::endl;
21292 0 : std::cout << "Memory pool size of SgOmpClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpClause) << std::endl;
21293 0 : std::cout << "Memory pool size of SgOmpAllocateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAllocateClause) << std::endl;
21294 0 : std::cout << "Memory pool size of SgOmpAllocatorClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAllocatorClause) << std::endl;
21295 0 : std::cout << "Memory pool size of SgOmpUsesAllocatorsClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUsesAllocatorsClause) << std::endl;
21296 0 : std::cout << "Memory pool size of SgOmpUsesAllocatorsDefination: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUsesAllocatorsDefination) << std::endl;
21297 0 : std::cout << "Memory pool size of SgOmpToClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpToClause) << std::endl;
21298 0 : std::cout << "Memory pool size of SgOmpFromClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpFromClause) << std::endl;
21299 0 : std::cout << "Memory pool size of SgOmpThreadsClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpThreadsClause) << std::endl;
21300 0 : std::cout << "Memory pool size of SgOmpSimdClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSimdClause) << std::endl;
21301 0 : std::cout << "Memory pool size of SgOmpBeginClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpBeginClause) << std::endl;
21302 0 : std::cout << "Memory pool size of SgOmpCollapseClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCollapseClause) << std::endl;
21303 0 : std::cout << "Memory pool size of SgOmpCopyinClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCopyinClause) << std::endl;
21304 0 : std::cout << "Memory pool size of SgOmpCopyprivateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCopyprivateClause) << std::endl;
21305 0 : std::cout << "Memory pool size of SgOmpDefaultClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDefaultClause) << std::endl;
21306 0 : std::cout << "Memory pool size of SgOmpEndClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpEndClause) << std::endl;
21307 0 : std::cout << "Memory pool size of SgOmpExpressionClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpExpressionClause) << std::endl;
21308 0 : std::cout << "Memory pool size of SgOmpFirstprivateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpFirstprivateClause) << std::endl;
21309 0 : std::cout << "Memory pool size of SgOmpIfClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpIfClause) << std::endl;
21310 0 : std::cout << "Memory pool size of SgOmpFinalClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpFinalClause) << std::endl;
21311 0 : std::cout << "Memory pool size of SgOmpPriorityClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpPriorityClause) << std::endl;
21312 0 : std::cout << "Memory pool size of SgOmpDeviceClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDeviceClause) << std::endl;
21313 0 : std::cout << "Memory pool size of SgOmpLastprivateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpLastprivateClause) << std::endl;
21314 0 : std::cout << "Memory pool size of SgOmpNowaitClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNowaitClause) << std::endl;
21315 0 : std::cout << "Memory pool size of SgOmpReadClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpReadClause) << std::endl;
21316 0 : std::cout << "Memory pool size of SgOmpWriteClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpWriteClause) << std::endl;
21317 0 : std::cout << "Memory pool size of SgOmpUpdateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUpdateClause) << std::endl;
21318 0 : std::cout << "Memory pool size of SgOmpDepobjUpdateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDepobjUpdateClause) << std::endl;
21319 0 : std::cout << "Memory pool size of SgOmpDestroyClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDestroyClause) << std::endl;
21320 0 : std::cout << "Memory pool size of SgOmpCaptureClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpCaptureClause) << std::endl;
21321 0 : std::cout << "Memory pool size of SgOmpSeqCstClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSeqCstClause) << std::endl;
21322 0 : std::cout << "Memory pool size of SgOmpAcqRelClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAcqRelClause) << std::endl;
21323 0 : std::cout << "Memory pool size of SgOmpReleaseClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpReleaseClause) << std::endl;
21324 0 : std::cout << "Memory pool size of SgOmpAcquireClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAcquireClause) << std::endl;
21325 0 : std::cout << "Memory pool size of SgOmpReverseOffloadClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpReverseOffloadClause) << std::endl;
21326 0 : std::cout << "Memory pool size of SgOmpUnifiedAddressClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUnifiedAddressClause) << std::endl;
21327 0 : std::cout << "Memory pool size of SgOmpUnifiedSharedMemoryClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUnifiedSharedMemoryClause) << std::endl;
21328 0 : std::cout << "Memory pool size of SgOmpDynamicAllocatorsClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDynamicAllocatorsClause) << std::endl;
21329 0 : std::cout << "Memory pool size of SgOmpAtomicDefaultMemOrderClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAtomicDefaultMemOrderClause) << std::endl;
21330 0 : std::cout << "Memory pool size of SgOmpExtImplementationDefinedRequirementClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpExtImplementationDefinedRequirementClause) << std::endl;
21331 0 : std::cout << "Memory pool size of SgOmpRelaxedClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpRelaxedClause) << std::endl;
21332 0 : std::cout << "Memory pool size of SgOmpParallelClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpParallelClause) << std::endl;
21333 0 : std::cout << "Memory pool size of SgOmpSectionsClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSectionsClause) << std::endl;
21334 0 : std::cout << "Memory pool size of SgOmpForClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpForClause) << std::endl;
21335 0 : std::cout << "Memory pool size of SgOmpTaskgroupClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskgroupClause) << std::endl;
21336 0 : std::cout << "Memory pool size of SgUpirNumUnitsField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirNumUnitsField) << std::endl;
21337 0 : std::cout << "Memory pool size of SgOmpNumTeamsClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNumTeamsClause) << std::endl;
21338 0 : std::cout << "Memory pool size of SgOmpGrainsizeClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpGrainsizeClause) << std::endl;
21339 0 : std::cout << "Memory pool size of SgOmpDetachClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDetachClause) << std::endl;
21340 0 : std::cout << "Memory pool size of SgOmpNumTasksClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNumTasksClause) << std::endl;
21341 0 : std::cout << "Memory pool size of SgOmpNogroupClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNogroupClause) << std::endl;
21342 0 : std::cout << "Memory pool size of SgOmpHintClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpHintClause) << std::endl;
21343 0 : std::cout << "Memory pool size of SgOmpOrderClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpOrderClause) << std::endl;
21344 0 : std::cout << "Memory pool size of SgOmpDistScheduleClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDistScheduleClause) << std::endl;
21345 0 : std::cout << "Memory pool size of SgOmpBindClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpBindClause) << std::endl;
21346 0 : std::cout << "Memory pool size of SgOmpNontemporalClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNontemporalClause) << std::endl;
21347 0 : std::cout << "Memory pool size of SgOmpInclusiveClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpInclusiveClause) << std::endl;
21348 0 : std::cout << "Memory pool size of SgOmpExclusiveClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpExclusiveClause) << std::endl;
21349 0 : std::cout << "Memory pool size of SgOmpIsDevicePtrClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpIsDevicePtrClause) << std::endl;
21350 0 : std::cout << "Memory pool size of SgOmpUseDevicePtrClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUseDevicePtrClause) << std::endl;
21351 0 : std::cout << "Memory pool size of SgOmpUseDeviceAddrClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUseDeviceAddrClause) << std::endl;
21352 0 : std::cout << "Memory pool size of SgOmpThreadLimitClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpThreadLimitClause) << std::endl;
21353 0 : std::cout << "Memory pool size of SgOmpOrderedClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpOrderedClause) << std::endl;
21354 0 : std::cout << "Memory pool size of SgOmpPrivateClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpPrivateClause) << std::endl;
21355 0 : std::cout << "Memory pool size of SgOmpReductionClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpReductionClause) << std::endl;
21356 0 : std::cout << "Memory pool size of SgOmpInReductionClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpInReductionClause) << std::endl;
21357 0 : std::cout << "Memory pool size of SgOmpTaskReductionClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpTaskReductionClause) << std::endl;
21358 0 : std::cout << "Memory pool size of SgOmpDefaultmapClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDefaultmapClause) << std::endl;
21359 0 : std::cout << "Memory pool size of SgOmpScheduleClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpScheduleClause) << std::endl;
21360 0 : std::cout << "Memory pool size of SgOmpSharedClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSharedClause) << std::endl;
21361 0 : std::cout << "Memory pool size of SgOmpUntiedClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUntiedClause) << std::endl;
21362 0 : std::cout << "Memory pool size of SgOmpMergeableClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMergeableClause) << std::endl;
21363 0 : std::cout << "Memory pool size of SgOmpVariablesClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpVariablesClause) << std::endl;
21364 0 : std::cout << "Memory pool size of SgOmpMapClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpMapClause) << std::endl;
21365 0 : std::cout << "Memory pool size of SgOmpSafelenClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSafelenClause) << std::endl;
21366 0 : std::cout << "Memory pool size of SgOmpSimdlenClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSimdlenClause) << std::endl;
21367 0 : std::cout << "Memory pool size of SgOmpLinearClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpLinearClause) << std::endl;
21368 0 : std::cout << "Memory pool size of SgOmpUniformClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpUniformClause) << std::endl;
21369 0 : std::cout << "Memory pool size of SgOmpAlignedClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAlignedClause) << std::endl;
21370 0 : std::cout << "Memory pool size of SgOmpProcBindClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpProcBindClause) << std::endl;
21371 0 : std::cout << "Memory pool size of SgOmpAtomicClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAtomicClause) << std::endl;
21372 0 : std::cout << "Memory pool size of SgOmpInbranchClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpInbranchClause) << std::endl;
21373 0 : std::cout << "Memory pool size of SgOmpNotinbranchClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpNotinbranchClause) << std::endl;
21374 0 : std::cout << "Memory pool size of SgOmpDependClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpDependClause) << std::endl;
21375 0 : std::cout << "Memory pool size of SgOmpAffinityClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpAffinityClause) << std::endl;
21376 0 : std::cout << "Memory pool size of SgOmpWhenClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpWhenClause) << std::endl;
21377 0 : std::cout << "Memory pool size of SgOmpFullClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpFullClause) << std::endl;
21378 0 : std::cout << "Memory pool size of SgOmpPartialClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpPartialClause) << std::endl;
21379 0 : std::cout << "Memory pool size of SgOmpSizesClause: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOmpSizesClause) << std::endl;
21380 0 : std::cout << "Memory pool size of SgUpirBranchField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirBranchField) << std::endl;
21381 0 : std::cout << "Memory pool size of SgUpirNestedLevelField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirNestedLevelField) << std::endl;
21382 0 : std::cout << "Memory pool size of SgUpirNestedParentField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirNestedParentField) << std::endl;
21383 0 : std::cout << "Memory pool size of SgUpirNestedChildField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirNestedChildField) << std::endl;
21384 0 : std::cout << "Memory pool size of SgUpirSyncField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirSyncField) << std::endl;
21385 0 : std::cout << "Memory pool size of SgUpirDataField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirDataField) << std::endl;
21386 0 : std::cout << "Memory pool size of SgUpirDataItemField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirDataItemField) << std::endl;
21387 0 : std::cout << "Memory pool size of SgUpirTargetField: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpirTargetField) << std::endl;
21388 0 : std::cout << "Memory pool size of SgOpenclAccessModeModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOpenclAccessModeModifier) << std::endl;
21389 0 : std::cout << "Memory pool size of SgOpenStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOpenStatement) << std::endl;
21390 0 : std::cout << "Memory pool size of SgOptions: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOptions) << std::endl;
21391 0 : std::cout << "Memory pool size of SgOrOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgOrOp) << std::endl;
21392 0 : std::cout << "Memory pool size of SgParameterStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgParameterStatement) << std::endl;
21393 0 : std::cout << "Memory pool size of SgPartialFunctionModifierType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPartialFunctionModifierType) << std::endl;
21394 0 : std::cout << "Memory pool size of SgPartialFunctionType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPartialFunctionType) << std::endl;
21395 0 : std::cout << "Memory pool size of SgPassStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPassStatement) << std::endl;
21396 0 : std::cout << "Memory pool size of SgPlusAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPlusAssignOp) << std::endl;
21397 0 : std::cout << "Memory pool size of SgPlusPlusOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPlusPlusOp) << std::endl;
21398 0 : std::cout << "Memory pool size of SgPntrArrRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPntrArrRefExp) << std::endl;
21399 0 : std::cout << "Memory pool size of SgPointerAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPointerAssignOp) << std::endl;
21400 0 : std::cout << "Memory pool size of SgPointerDerefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPointerDerefExp) << std::endl;
21401 0 : std::cout << "Memory pool size of SgPointerMemberType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPointerMemberType) << std::endl;
21402 0 : std::cout << "Memory pool size of SgPointerType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPointerType) << std::endl;
21403 0 : std::cout << "Memory pool size of SgPowerOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPowerOp) << std::endl;
21404 0 : std::cout << "Memory pool size of SgPragma: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPragma) << std::endl;
21405 0 : std::cout << "Memory pool size of SgPragmaDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPragmaDeclaration) << std::endl;
21406 0 : std::cout << "Memory pool size of SgPrintStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPrintStatement) << std::endl;
21407 0 : std::cout << "Memory pool size of SgProcedureHeaderStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgProcedureHeaderStatement) << std::endl;
21408 0 : std::cout << "Memory pool size of SgProgramHeaderStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgProgramHeaderStatement) << std::endl;
21409 0 : std::cout << "Memory pool size of SgProject: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgProject) << std::endl;
21410 0 : std::cout << "Memory pool size of SgPseudoDestructorRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgPseudoDestructorRefExp) << std::endl;
21411 0 : std::cout << "Memory pool size of SgQualifiedName: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgQualifiedName) << std::endl;
21412 0 : std::cout << "Memory pool size of SgQualifiedNameType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgQualifiedNameType) << std::endl;
21413 0 : std::cout << "Memory pool size of SgRangeExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRangeExp) << std::endl;
21414 0 : std::cout << "Memory pool size of SgRangeBasedForStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRangeBasedForStatement) << std::endl;
21415 0 : std::cout << "Memory pool size of SgReadStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgReadStatement) << std::endl;
21416 0 : std::cout << "Memory pool size of SgRealPartOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRealPartOp) << std::endl;
21417 0 : std::cout << "Memory pool size of SgRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRefExp) << std::endl;
21418 0 : std::cout << "Memory pool size of SgReferenceType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgReferenceType) << std::endl;
21419 0 : std::cout << "Memory pool size of SgRenamePair: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRenamePair) << std::endl;
21420 0 : std::cout << "Memory pool size of SgRenameSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRenameSymbol) << std::endl;
21421 0 : std::cout << "Memory pool size of SgReturnStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgReturnStmt) << std::endl;
21422 0 : std::cout << "Memory pool size of SgRewindStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRewindStatement) << std::endl;
21423 0 : std::cout << "Memory pool size of SgRshiftAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRshiftAssignOp) << std::endl;
21424 0 : std::cout << "Memory pool size of SgRshiftOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRshiftOp) << std::endl;
21425 0 : std::cout << "Memory pool size of SgRvalueReferenceType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgRvalueReferenceType) << std::endl;
21426 0 : std::cout << "Memory pool size of SgScopeOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgScopeOp) << std::endl;
21427 0 : std::cout << "Memory pool size of SgScopeStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgScopeStatement) << std::endl;
21428 0 : std::cout << "Memory pool size of SgSequenceStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSequenceStatement) << std::endl;
21429 0 : std::cout << "Memory pool size of SgSetComprehension: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSetComprehension) << std::endl;
21430 0 : std::cout << "Memory pool size of SgShortVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgShortVal) << std::endl;
21431 0 : std::cout << "Memory pool size of SgSIMDBinaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDBinaryOp) << std::endl;
21432 0 : std::cout << "Memory pool size of SgSIMDAddOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDAddOp) << std::endl;
21433 0 : std::cout << "Memory pool size of SgSIMDSubOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDSubOp) << std::endl;
21434 0 : std::cout << "Memory pool size of SgSIMDMulOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDMulOp) << std::endl;
21435 0 : std::cout << "Memory pool size of SgSIMDDivOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDDivOp) << std::endl;
21436 0 : std::cout << "Memory pool size of SgSIMDFmaOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDFmaOp) << std::endl;
21437 0 : std::cout << "Memory pool size of SgSIMDLoad: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDLoad) << std::endl;
21438 0 : std::cout << "Memory pool size of SgSIMDBroadcast: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDBroadcast) << std::endl;
21439 0 : std::cout << "Memory pool size of SgSIMDStore: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDStore) << std::endl;
21440 0 : std::cout << "Memory pool size of SgSIMDPartialStore: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDPartialStore) << std::endl;
21441 0 : std::cout << "Memory pool size of SgSIMDScalarStore: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDScalarStore) << std::endl;
21442 0 : std::cout << "Memory pool size of SgSIMDGather: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDGather) << std::endl;
21443 0 : std::cout << "Memory pool size of SgSIMDExplicitGather: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDExplicitGather) << std::endl;
21444 0 : std::cout << "Memory pool size of SgSIMDScatter: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSIMDScatter) << std::endl;
21445 0 : std::cout << "Memory pool size of SgSizeOfOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSizeOfOp) << std::endl;
21446 0 : std::cout << "Memory pool size of SgAlignOfOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgAlignOfOp) << std::endl;
21447 0 : std::cout << "Memory pool size of SgSourceFile: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSourceFile) << std::endl;
21448 0 : std::cout << "Memory pool size of SgSpaceshipOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSpaceshipOp) << std::endl;
21449 0 : std::cout << "Memory pool size of SgSpawnStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSpawnStmt) << std::endl;
21450 0 : std::cout << "Memory pool size of SgSyncAllStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSyncAllStatement) << std::endl;
21451 0 : std::cout << "Memory pool size of SgSyncImagesStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSyncImagesStatement) << std::endl;
21452 0 : std::cout << "Memory pool size of SgSyncMemoryStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSyncMemoryStatement) << std::endl;
21453 0 : std::cout << "Memory pool size of SgSyncTeamStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSyncTeamStatement) << std::endl;
21454 0 : std::cout << "Memory pool size of SgLockStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgLockStatement) << std::endl;
21455 0 : std::cout << "Memory pool size of SgUnlockStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnlockStatement) << std::endl;
21456 0 : std::cout << "Memory pool size of SgProcessControlStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgProcessControlStatement) << std::endl;
21457 0 : std::cout << "Memory pool size of SgSpecialFunctionModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSpecialFunctionModifier) << std::endl;
21458 0 : std::cout << "Memory pool size of SgStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStatement) << std::endl;
21459 0 : std::cout << "Memory pool size of SgStaticAssertionDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStaticAssertionDeclaration) << std::endl;
21460 0 : std::cout << "Memory pool size of SgStmtDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStmtDeclarationStatement) << std::endl;
21461 0 : std::cout << "Memory pool size of SgStatementExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStatementExpression) << std::endl;
21462 0 : std::cout << "Memory pool size of SgStatementFunctionStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStatementFunctionStatement) << std::endl;
21463 0 : std::cout << "Memory pool size of SgStorageModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStorageModifier) << std::endl;
21464 0 : std::cout << "Memory pool size of SgStringConversion: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStringConversion) << std::endl;
21465 0 : std::cout << "Memory pool size of SgStringKeyedBidirectionalGraph: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStringKeyedBidirectionalGraph) << std::endl;
21466 0 : std::cout << "Memory pool size of SgStringVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStringVal) << std::endl;
21467 0 : std::cout << "Memory pool size of SgStructureModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgStructureModifier) << std::endl;
21468 0 : std::cout << "Memory pool size of SgSubscriptExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSubscriptExpression) << std::endl;
21469 0 : std::cout << "Memory pool size of SgSubtractOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSubtractOp) << std::endl;
21470 0 : std::cout << "Memory pool size of SgSupport: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSupport) << std::endl;
21471 0 : std::cout << "Memory pool size of SgSwitchStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSwitchStatement) << std::endl;
21472 0 : std::cout << "Memory pool size of SgSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSymbol) << std::endl;
21473 0 : std::cout << "Memory pool size of SgSymbolTable: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSymbolTable) << std::endl;
21474 0 : std::cout << "Memory pool size of SgTemplateArgument: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateArgument) << std::endl;
21475 0 : std::cout << "Memory pool size of SgTemplateArgumentList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateArgumentList) << std::endl;
21476 0 : std::cout << "Memory pool size of SgTemplateDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateDeclaration) << std::endl;
21477 0 : std::cout << "Memory pool size of SgTemplateClassDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateClassDeclaration) << std::endl;
21478 0 : std::cout << "Memory pool size of SgTemplateClassSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateClassSymbol) << std::endl;
21479 0 : std::cout << "Memory pool size of SgTemplateFunctionDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateFunctionDeclaration) << std::endl;
21480 0 : std::cout << "Memory pool size of SgTemplateFunctionRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateFunctionRefExp) << std::endl;
21481 0 : std::cout << "Memory pool size of SgTemplateFunctionSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateFunctionSymbol) << std::endl;
21482 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateMemberFunctionDeclaration) << std::endl;
21483 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateMemberFunctionRefExp) << std::endl;
21484 0 : std::cout << "Memory pool size of SgTemplateMemberFunctionSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateMemberFunctionSymbol) << std::endl;
21485 0 : std::cout << "Memory pool size of SgTemplateTypedefDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateTypedefDeclaration) << std::endl;
21486 0 : std::cout << "Memory pool size of SgTemplateTypedefSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateTypedefSymbol) << std::endl;
21487 0 : std::cout << "Memory pool size of SgTemplateVariableDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateVariableDeclaration) << std::endl;
21488 0 : std::cout << "Memory pool size of SgTemplateVariableSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateVariableSymbol) << std::endl;
21489 0 : std::cout << "Memory pool size of SgTemplateClassDefinition: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateClassDefinition) << std::endl;
21490 0 : std::cout << "Memory pool size of SgTemplateFunctionDefinition: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateFunctionDefinition) << std::endl;
21491 0 : std::cout << "Memory pool size of SgTemplateInstantiationDecl: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationDecl) << std::endl;
21492 0 : std::cout << "Memory pool size of SgTemplateInstantiationDefn: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationDefn) << std::endl;
21493 0 : std::cout << "Memory pool size of SgTemplateInstantiationDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationDirectiveStatement) << std::endl;
21494 0 : std::cout << "Memory pool size of SgTemplateInstantiationFunctionDecl: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationFunctionDecl) << std::endl;
21495 0 : std::cout << "Memory pool size of SgTemplateInstantiationMemberFunctionDecl: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationMemberFunctionDecl) << std::endl;
21496 0 : std::cout << "Memory pool size of SgTemplateInstantiationTypedefDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateInstantiationTypedefDeclaration) << std::endl;
21497 0 : std::cout << "Memory pool size of SgTemplateParameter: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateParameter) << std::endl;
21498 0 : std::cout << "Memory pool size of SgTemplateParameterVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateParameterVal) << std::endl;
21499 0 : std::cout << "Memory pool size of SgTemplateParameterList: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateParameterList) << std::endl;
21500 0 : std::cout << "Memory pool size of SgTemplateSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateSymbol) << std::endl;
21501 0 : std::cout << "Memory pool size of SgTemplateType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTemplateType) << std::endl;
21502 0 : std::cout << "Memory pool size of SgThisExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgThisExp) << std::endl;
21503 0 : std::cout << "Memory pool size of SgTypeTraitBuiltinOperator: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeTraitBuiltinOperator) << std::endl;
21504 0 : std::cout << "Memory pool size of SgSuperExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgSuperExp) << std::endl;
21505 0 : std::cout << "Memory pool size of SgThrowOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgThrowOp) << std::endl;
21506 0 : std::cout << "Memory pool size of SgToken: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgToken) << std::endl;
21507 0 : std::cout << "Memory pool size of SgTryStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTryStmt) << std::endl;
21508 0 : std::cout << "Memory pool size of SgTupleExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTupleExp) << std::endl;
21509 0 : std::cout << "Memory pool size of SgType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgType) << std::endl;
21510 0 : std::cout << "Memory pool size of SgTypeBool: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeBool) << std::endl;
21511 0 : std::cout << "Memory pool size of SgTypeChar: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeChar) << std::endl;
21512 0 : std::cout << "Memory pool size of SgTypeChar16: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeChar16) << std::endl;
21513 0 : std::cout << "Memory pool size of SgTypeChar32: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeChar32) << std::endl;
21514 0 : std::cout << "Memory pool size of SgTypeComplex: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeComplex) << std::endl;
21515 0 : std::cout << "Memory pool size of SgTypeDefault: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeDefault) << std::endl;
21516 0 : std::cout << "Memory pool size of SgTypeExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeExpression) << std::endl;
21517 0 : std::cout << "Memory pool size of SgTypeLabel: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeLabel) << std::endl;
21518 0 : std::cout << "Memory pool size of SgTypeDouble: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeDouble) << std::endl;
21519 0 : std::cout << "Memory pool size of SgTypeEllipse: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeEllipse) << std::endl;
21520 0 : std::cout << "Memory pool size of SgTypeFixed: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeFixed) << std::endl;
21521 0 : std::cout << "Memory pool size of SgTypeFloat: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeFloat) << std::endl;
21522 0 : std::cout << "Memory pool size of SgTypeFloat128: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeFloat128) << std::endl;
21523 0 : std::cout << "Memory pool size of SgTypeFloat80: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeFloat80) << std::endl;
21524 0 : std::cout << "Memory pool size of SgTypeGlobalVoid: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeGlobalVoid) << std::endl;
21525 0 : std::cout << "Memory pool size of SgTypeIdOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeIdOp) << std::endl;
21526 0 : std::cout << "Memory pool size of SgTypeImaginary: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeImaginary) << std::endl;
21527 0 : std::cout << "Memory pool size of SgTypeInt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeInt) << std::endl;
21528 0 : std::cout << "Memory pool size of SgTypeLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeLong) << std::endl;
21529 0 : std::cout << "Memory pool size of SgTypeLongDouble: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeLongDouble) << std::endl;
21530 0 : std::cout << "Memory pool size of SgTypeLongLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeLongLong) << std::endl;
21531 0 : std::cout << "Memory pool size of SgTypeModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeModifier) << std::endl;
21532 0 : std::cout << "Memory pool size of SgTypeMatrix: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeMatrix) << std::endl;
21533 0 : std::cout << "Memory pool size of SgTypeTuple: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeTuple) << std::endl;
21534 0 : std::cout << "Memory pool size of SgTypeNullptr: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeNullptr) << std::endl;
21535 0 : std::cout << "Memory pool size of SgTypeOfType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeOfType) << std::endl;
21536 0 : std::cout << "Memory pool size of SgTypeShort: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeShort) << std::endl;
21537 0 : std::cout << "Memory pool size of SgTypeSigned128bitInteger: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSigned128bitInteger) << std::endl;
21538 0 : std::cout << "Memory pool size of SgTypeSignedChar: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSignedChar) << std::endl;
21539 0 : std::cout << "Memory pool size of SgTypeSignedInt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSignedInt) << std::endl;
21540 0 : std::cout << "Memory pool size of SgTypeSignedLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSignedLong) << std::endl;
21541 0 : std::cout << "Memory pool size of SgTypeSignedLongLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSignedLongLong) << std::endl;
21542 0 : std::cout << "Memory pool size of SgTypeSignedShort: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeSignedShort) << std::endl;
21543 0 : std::cout << "Memory pool size of SgTypeString: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeString) << std::endl;
21544 0 : std::cout << "Memory pool size of SgTypeUnknown: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnknown) << std::endl;
21545 0 : std::cout << "Memory pool size of SgTypeUnsigned128bitInteger: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsigned128bitInteger) << std::endl;
21546 0 : std::cout << "Memory pool size of SgTypeUnsignedChar: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsignedChar) << std::endl;
21547 0 : std::cout << "Memory pool size of SgTypeUnsignedInt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsignedInt) << std::endl;
21548 0 : std::cout << "Memory pool size of SgTypeUnsignedLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsignedLong) << std::endl;
21549 0 : std::cout << "Memory pool size of SgTypeUnsignedLongLong: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsignedLongLong) << std::endl;
21550 0 : std::cout << "Memory pool size of SgTypeUnsignedShort: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeUnsignedShort) << std::endl;
21551 0 : std::cout << "Memory pool size of SgTypeVoid: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeVoid) << std::endl;
21552 0 : std::cout << "Memory pool size of SgTypeWchar: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeWchar) << std::endl;
21553 0 : std::cout << "Memory pool size of SgTypedefDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypedefDeclaration) << std::endl;
21554 0 : std::cout << "Memory pool size of SgTypedefSeq: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypedefSeq) << std::endl;
21555 0 : std::cout << "Memory pool size of SgTypedefSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypedefSymbol) << std::endl;
21556 0 : std::cout << "Memory pool size of SgTypedefType: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypedefType) << std::endl;
21557 0 : std::cout << "Memory pool size of SgUPC_AccessModifier: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUPC_AccessModifier) << std::endl;
21558 0 : std::cout << "Memory pool size of SgUnaryAddOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnaryAddOp) << std::endl;
21559 0 : std::cout << "Memory pool size of SgUnaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnaryOp) << std::endl;
21560 0 : std::cout << "Memory pool size of SgUndefDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUndefDirectiveStatement) << std::endl;
21561 0 : std::cout << "Memory pool size of SgUndirectedGraphEdge: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUndirectedGraphEdge) << std::endl;
21562 0 : std::cout << "Memory pool size of SgUnknownArrayOrFunctionReference: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnknownArrayOrFunctionReference) << std::endl;
21563 0 : std::cout << "Memory pool size of SgUnknownFile: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnknownFile) << std::endl;
21564 0 : std::cout << "Memory pool size of SgUnparse_Info: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnparse_Info) << std::endl;
21565 0 : std::cout << "Memory pool size of SgUnsignedCharVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnsignedCharVal) << std::endl;
21566 0 : std::cout << "Memory pool size of SgUnsignedIntVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnsignedIntVal) << std::endl;
21567 0 : std::cout << "Memory pool size of SgUnsignedLongLongIntVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnsignedLongLongIntVal) << std::endl;
21568 0 : std::cout << "Memory pool size of SgUnsignedLongVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnsignedLongVal) << std::endl;
21569 0 : std::cout << "Memory pool size of SgUnsignedShortVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUnsignedShortVal) << std::endl;
21570 0 : std::cout << "Memory pool size of SgUpcBarrierStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcBarrierStatement) << std::endl;
21571 0 : std::cout << "Memory pool size of SgUpcBlocksizeofExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcBlocksizeofExpression) << std::endl;
21572 0 : std::cout << "Memory pool size of SgUpcElemsizeofExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcElemsizeofExpression) << std::endl;
21573 0 : std::cout << "Memory pool size of SgUpcFenceStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcFenceStatement) << std::endl;
21574 0 : std::cout << "Memory pool size of SgUpcForAllStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcForAllStatement) << std::endl;
21575 0 : std::cout << "Memory pool size of SgUpcLocalsizeofExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcLocalsizeofExpression) << std::endl;
21576 0 : std::cout << "Memory pool size of SgUpcMythread: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcMythread) << std::endl;
21577 0 : std::cout << "Memory pool size of SgUpcNotifyStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcNotifyStatement) << std::endl;
21578 0 : std::cout << "Memory pool size of SgUpcThreads: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcThreads) << std::endl;
21579 0 : std::cout << "Memory pool size of SgUpcWaitStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUpcWaitStatement) << std::endl;
21580 0 : std::cout << "Memory pool size of SgUseStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUseStatement) << std::endl;
21581 0 : std::cout << "Memory pool size of SgUserDefinedBinaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUserDefinedBinaryOp) << std::endl;
21582 0 : std::cout << "Memory pool size of SgUserDefinedUnaryOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUserDefinedUnaryOp) << std::endl;
21583 0 : std::cout << "Memory pool size of SgUsingDeclarationStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUsingDeclarationStatement) << std::endl;
21584 0 : std::cout << "Memory pool size of SgUsingDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgUsingDirectiveStatement) << std::endl;
21585 0 : std::cout << "Memory pool size of SgValueExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgValueExp) << std::endl;
21586 0 : std::cout << "Memory pool size of SgVarArgCopyOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarArgCopyOp) << std::endl;
21587 0 : std::cout << "Memory pool size of SgVarArgEndOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarArgEndOp) << std::endl;
21588 0 : std::cout << "Memory pool size of SgVarArgOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarArgOp) << std::endl;
21589 0 : std::cout << "Memory pool size of SgVarArgStartOneOperandOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarArgStartOneOperandOp) << std::endl;
21590 0 : std::cout << "Memory pool size of SgVarArgStartOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarArgStartOp) << std::endl;
21591 0 : std::cout << "Memory pool size of SgVarRefExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVarRefExp) << std::endl;
21592 0 : std::cout << "Memory pool size of SgVariableDeclaration: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVariableDeclaration) << std::endl;
21593 0 : std::cout << "Memory pool size of SgVariableDefinition: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVariableDefinition) << std::endl;
21594 0 : std::cout << "Memory pool size of SgVariableSymbol: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVariableSymbol) << std::endl;
21595 0 : std::cout << "Memory pool size of SgVariantExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVariantExpression) << std::endl;
21596 0 : std::cout << "Memory pool size of SgVariantStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVariantStatement) << std::endl;
21597 0 : std::cout << "Memory pool size of SgVoidVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgVoidVal) << std::endl;
21598 0 : std::cout << "Memory pool size of SgWaitStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWaitStatement) << std::endl;
21599 0 : std::cout << "Memory pool size of SgWarningDirectiveStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWarningDirectiveStatement) << std::endl;
21600 0 : std::cout << "Memory pool size of SgWithStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWithStatement) << std::endl;
21601 0 : std::cout << "Memory pool size of SgWcharVal: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWcharVal) << std::endl;
21602 0 : std::cout << "Memory pool size of SgWhereStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWhereStatement) << std::endl;
21603 0 : std::cout << "Memory pool size of SgWhileStmt: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWhileStmt) << std::endl;
21604 0 : std::cout << "Memory pool size of SgWriteStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgWriteStatement) << std::endl;
21605 0 : std::cout << "Memory pool size of SgXorAssignOp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgXorAssignOp) << std::endl;
21606 0 : std::cout << "Memory pool size of SgYieldExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgYieldExpression) << std::endl;
21607 0 : std::cout << "Memory pool size of Sg_File_Info: " << vectorOfASTs[index]->getMemoryPoolSize(V_Sg_File_Info) << std::endl;
21608 0 : std::cout << "Memory pool size of SgTypeCAFTeam: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeCAFTeam) << std::endl;
21609 0 : std::cout << "Memory pool size of SgCAFWithTeamStatement: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCAFWithTeamStatement) << std::endl;
21610 0 : std::cout << "Memory pool size of SgCAFCoExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCAFCoExpression) << std::endl;
21611 0 : std::cout << "Memory pool size of SgCallExpression: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgCallExpression) << std::endl;
21612 0 : std::cout << "Memory pool size of SgTypeCrayPointer: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgTypeCrayPointer) << std::endl;
21613 0 : std::cout << "Memory pool size of SgClassExp: " << vectorOfASTs[index]->getMemoryPoolSize(V_SgClassExp) << std::endl;
21614 :
21615 : /* #line 477 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
21616 0 : std::cout << " Total number of IR nodes in contained in the memory pools: "
21617 0 : << vectorOfASTs[index]->getTotalNumberOfASTIRNodes() << std::endl << std::endl;
21618 0 : return;
21619 : }
21620 :
21621 :
21622 : AstData*
21623 2 : AST_FILE_IO::getAst (int index)
21624 : {
21625 2 : assert( index <= (int)vectorOfASTs.size() );
21626 2 : return vectorOfASTs[index];
21627 : }
21628 :
21629 :
21630 : AstData*
21631 0 : AST_FILE_IO::getAstWithRoot (SgProject* root)
21632 : {
21633 0 : std::vector<AstSpecificDataManagingClass*>:: iterator astIter = vectorOfASTs.begin();
21634 0 : while ( astIter != vectorOfASTs.end() && (*astIter)->getRootOfAst() != root )
21635 : {
21636 0 : astIter++;
21637 : }
21638 0 : assert( astIter!= vectorOfASTs.end() );
21639 0 : return *astIter;
21640 : }
21641 :
21642 :
21643 : /* JW (06/21/2006) Refactored this to have a write-to-stream function so
21644 : * stringstreams can be used */
21645 : void
21646 3 : AST_FILE_IO :: writeASTToStream ( std::ostream& out) {
21647 : // DQ (4/22/2006): Added timer information for AST File I/O
21648 3 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile():");
21649 :
21650 3 : assert ( freepointersOfCurrentAstAreSetToGlobalIndices == true );
21651 3 : assert ( 0 < getTotalNumberOfNodesOfAstInMemoryPool() );
21652 6 : std::string startString = "ROSE_AST_BINARY_START";
21653 3 : out.write ( startString.c_str(), startString.size() );
21654 :
21655 : // 1. Write the accumulatedPoolSizesOfAstInMemoryPool
21656 3 : AstDataStorageClass staticTemp;
21657 3 : staticTemp.pickOutIRNodeData(actualRebuildAst);
21658 :
21659 3 : {
21660 : // DQ (4/22/2006): Added timer information for AST File I/O
21661 6 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile() raw file write part 1 (memory pool data):");
21662 3 : out.write ( (char*)(&staticTemp) , sizeof(AstDataStorageClass) );
21663 : }
21664 3 : {
21665 : // DQ (4/22/2006): Added timer information for AST File I/O
21666 6 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile() raw file write part 2 (easy storage data):");
21667 3 : AstDataStorageClass::writeEasyStorageDataToFile(out);
21668 : }
21669 :
21670 : // 1.a Introducing a marker to check the right position in the file
21671 :
21672 6 : std::string markString = "#########";
21673 3 : out.write ( markString.c_str(), markString.size() );
21674 :
21675 : // 2. Initialize the StorageClass and write
21676 :
21677 : // DQ (9/3/2015): Fixed size and unsigned-ness of type.
21678 : // int sizeOfActualPool = 0;
21679 3 : unsigned long sizeOfActualPool = 0 ;
21680 : // DQ (9/3/2015): Fixed unsigned-ness of type.
21681 3 : unsigned long storageClassIndex = 0;
21682 :
21683 3 : {
21684 : // DQ (4/22/2006): Added timer information for AST File I/O
21685 6 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile() raw file write part 3 (rest of AST data):");
21686 :
21687 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAccessModifier );
21688 3 : storageClassIndex = 0 ;
21689 3 : if ( 0 < sizeOfActualPool )
21690 : {
21691 0 : SgAccessModifierStorageClass* storageArray = new SgAccessModifierStorageClass[sizeOfActualPool] ;
21692 0 : storageClassIndex = SgAccessModifier::initializeStorageClassArray (storageArray); ;
21693 0 : assert ( storageClassIndex == sizeOfActualPool );
21694 0 : out.write ( (char*) (storageArray) , sizeof ( SgAccessModifierStorageClass ) * sizeOfActualPool) ;
21695 0 : delete [] storageArray;
21696 : }
21697 :
21698 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgActualArgumentExpression );
21699 3 : storageClassIndex = 0 ;
21700 3 : if ( 0 < sizeOfActualPool )
21701 : {
21702 0 : SgActualArgumentExpressionStorageClass* storageArray = new SgActualArgumentExpressionStorageClass[sizeOfActualPool] ;
21703 0 : storageClassIndex = SgActualArgumentExpression::initializeStorageClassArray (storageArray); ;
21704 0 : assert ( storageClassIndex == sizeOfActualPool );
21705 0 : out.write ( (char*) (storageArray) , sizeof ( SgActualArgumentExpressionStorageClass ) * sizeOfActualPool) ;
21706 0 : delete [] storageArray;
21707 0 : SgActualArgumentExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
21708 : }
21709 :
21710 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAddOp );
21711 3 : storageClassIndex = 0 ;
21712 3 : if ( 0 < sizeOfActualPool )
21713 : {
21714 191 : SgAddOpStorageClass* storageArray = new SgAddOpStorageClass[sizeOfActualPool] ;
21715 1 : storageClassIndex = SgAddOp::initializeStorageClassArray (storageArray); ;
21716 1 : assert ( storageClassIndex == sizeOfActualPool );
21717 1 : out.write ( (char*) (storageArray) , sizeof ( SgAddOpStorageClass ) * sizeOfActualPool) ;
21718 1 : delete [] storageArray;
21719 1 : SgAddOpStorageClass :: writeEasyStorageDataToFile(out) ;
21720 : }
21721 :
21722 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAddressOfOp );
21723 3 : storageClassIndex = 0 ;
21724 3 : if ( 0 < sizeOfActualPool )
21725 : {
21726 85 : SgAddressOfOpStorageClass* storageArray = new SgAddressOfOpStorageClass[sizeOfActualPool] ;
21727 1 : storageClassIndex = SgAddressOfOp::initializeStorageClassArray (storageArray); ;
21728 1 : assert ( storageClassIndex == sizeOfActualPool );
21729 1 : out.write ( (char*) (storageArray) , sizeof ( SgAddressOfOpStorageClass ) * sizeOfActualPool) ;
21730 1 : delete [] storageArray;
21731 1 : SgAddressOfOpStorageClass :: writeEasyStorageDataToFile(out) ;
21732 : }
21733 :
21734 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAggregateInitializer );
21735 3 : storageClassIndex = 0 ;
21736 3 : if ( 0 < sizeOfActualPool )
21737 : {
21738 4 : SgAggregateInitializerStorageClass* storageArray = new SgAggregateInitializerStorageClass[sizeOfActualPool] ;
21739 1 : storageClassIndex = SgAggregateInitializer::initializeStorageClassArray (storageArray); ;
21740 1 : assert ( storageClassIndex == sizeOfActualPool );
21741 1 : out.write ( (char*) (storageArray) , sizeof ( SgAggregateInitializerStorageClass ) * sizeOfActualPool) ;
21742 1 : delete [] storageArray;
21743 1 : SgAggregateInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
21744 : }
21745 :
21746 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAliasSymbol );
21747 3 : storageClassIndex = 0 ;
21748 3 : if ( 0 < sizeOfActualPool )
21749 : {
21750 13988 : SgAliasSymbolStorageClass* storageArray = new SgAliasSymbolStorageClass[sizeOfActualPool] ;
21751 3 : storageClassIndex = SgAliasSymbol::initializeStorageClassArray (storageArray); ;
21752 3 : assert ( storageClassIndex == sizeOfActualPool );
21753 3 : out.write ( (char*) (storageArray) , sizeof ( SgAliasSymbolStorageClass ) * sizeOfActualPool) ;
21754 3 : delete [] storageArray;
21755 3 : SgAliasSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
21756 : }
21757 :
21758 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAllocateStatement );
21759 3 : storageClassIndex = 0 ;
21760 3 : if ( 0 < sizeOfActualPool )
21761 : {
21762 0 : SgAllocateStatementStorageClass* storageArray = new SgAllocateStatementStorageClass[sizeOfActualPool] ;
21763 0 : storageClassIndex = SgAllocateStatement::initializeStorageClassArray (storageArray); ;
21764 0 : assert ( storageClassIndex == sizeOfActualPool );
21765 0 : out.write ( (char*) (storageArray) , sizeof ( SgAllocateStatementStorageClass ) * sizeOfActualPool) ;
21766 0 : delete [] storageArray;
21767 0 : SgAllocateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21768 : }
21769 :
21770 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAndAssignOp );
21771 3 : storageClassIndex = 0 ;
21772 3 : if ( 0 < sizeOfActualPool )
21773 : {
21774 0 : SgAndAssignOpStorageClass* storageArray = new SgAndAssignOpStorageClass[sizeOfActualPool] ;
21775 0 : storageClassIndex = SgAndAssignOp::initializeStorageClassArray (storageArray); ;
21776 0 : assert ( storageClassIndex == sizeOfActualPool );
21777 0 : out.write ( (char*) (storageArray) , sizeof ( SgAndAssignOpStorageClass ) * sizeOfActualPool) ;
21778 0 : delete [] storageArray;
21779 0 : SgAndAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
21780 : }
21781 :
21782 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAndOp );
21783 3 : storageClassIndex = 0 ;
21784 3 : if ( 0 < sizeOfActualPool )
21785 : {
21786 174 : SgAndOpStorageClass* storageArray = new SgAndOpStorageClass[sizeOfActualPool] ;
21787 1 : storageClassIndex = SgAndOp::initializeStorageClassArray (storageArray); ;
21788 1 : assert ( storageClassIndex == sizeOfActualPool );
21789 1 : out.write ( (char*) (storageArray) , sizeof ( SgAndOpStorageClass ) * sizeOfActualPool) ;
21790 1 : delete [] storageArray;
21791 1 : SgAndOpStorageClass :: writeEasyStorageDataToFile(out) ;
21792 : }
21793 :
21794 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgArithmeticIfStatement );
21795 3 : storageClassIndex = 0 ;
21796 3 : if ( 0 < sizeOfActualPool )
21797 : {
21798 0 : SgArithmeticIfStatementStorageClass* storageArray = new SgArithmeticIfStatementStorageClass[sizeOfActualPool] ;
21799 0 : storageClassIndex = SgArithmeticIfStatement::initializeStorageClassArray (storageArray); ;
21800 0 : assert ( storageClassIndex == sizeOfActualPool );
21801 0 : out.write ( (char*) (storageArray) , sizeof ( SgArithmeticIfStatementStorageClass ) * sizeOfActualPool) ;
21802 0 : delete [] storageArray;
21803 0 : SgArithmeticIfStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21804 : }
21805 :
21806 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgArrayType );
21807 3 : storageClassIndex = 0 ;
21808 3 : if ( 0 < sizeOfActualPool )
21809 : {
21810 110 : SgArrayTypeStorageClass* storageArray = new SgArrayTypeStorageClass[sizeOfActualPool] ;
21811 2 : storageClassIndex = SgArrayType::initializeStorageClassArray (storageArray); ;
21812 2 : assert ( storageClassIndex == sizeOfActualPool );
21813 2 : out.write ( (char*) (storageArray) , sizeof ( SgArrayTypeStorageClass ) * sizeOfActualPool) ;
21814 2 : delete [] storageArray;
21815 2 : SgArrayTypeStorageClass :: writeEasyStorageDataToFile(out) ;
21816 : }
21817 :
21818 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgArrowExp );
21819 3 : storageClassIndex = 0 ;
21820 3 : if ( 0 < sizeOfActualPool )
21821 : {
21822 1255 : SgArrowExpStorageClass* storageArray = new SgArrowExpStorageClass[sizeOfActualPool] ;
21823 1 : storageClassIndex = SgArrowExp::initializeStorageClassArray (storageArray); ;
21824 1 : assert ( storageClassIndex == sizeOfActualPool );
21825 1 : out.write ( (char*) (storageArray) , sizeof ( SgArrowExpStorageClass ) * sizeOfActualPool) ;
21826 1 : delete [] storageArray;
21827 1 : SgArrowExpStorageClass :: writeEasyStorageDataToFile(out) ;
21828 : }
21829 :
21830 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgArrowStarOp );
21831 3 : storageClassIndex = 0 ;
21832 3 : if ( 0 < sizeOfActualPool )
21833 : {
21834 5 : SgArrowStarOpStorageClass* storageArray = new SgArrowStarOpStorageClass[sizeOfActualPool] ;
21835 1 : storageClassIndex = SgArrowStarOp::initializeStorageClassArray (storageArray); ;
21836 1 : assert ( storageClassIndex == sizeOfActualPool );
21837 1 : out.write ( (char*) (storageArray) , sizeof ( SgArrowStarOpStorageClass ) * sizeOfActualPool) ;
21838 1 : delete [] storageArray;
21839 1 : SgArrowStarOpStorageClass :: writeEasyStorageDataToFile(out) ;
21840 : }
21841 :
21842 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAsmOp );
21843 3 : storageClassIndex = 0 ;
21844 3 : if ( 0 < sizeOfActualPool )
21845 : {
21846 0 : SgAsmOpStorageClass* storageArray = new SgAsmOpStorageClass[sizeOfActualPool] ;
21847 0 : storageClassIndex = SgAsmOp::initializeStorageClassArray (storageArray); ;
21848 0 : assert ( storageClassIndex == sizeOfActualPool );
21849 0 : out.write ( (char*) (storageArray) , sizeof ( SgAsmOpStorageClass ) * sizeOfActualPool) ;
21850 0 : delete [] storageArray;
21851 0 : SgAsmOpStorageClass :: writeEasyStorageDataToFile(out) ;
21852 : }
21853 :
21854 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAsmStmt );
21855 3 : storageClassIndex = 0 ;
21856 3 : if ( 0 < sizeOfActualPool )
21857 : {
21858 0 : SgAsmStmtStorageClass* storageArray = new SgAsmStmtStorageClass[sizeOfActualPool] ;
21859 0 : storageClassIndex = SgAsmStmt::initializeStorageClassArray (storageArray); ;
21860 0 : assert ( storageClassIndex == sizeOfActualPool );
21861 0 : out.write ( (char*) (storageArray) , sizeof ( SgAsmStmtStorageClass ) * sizeOfActualPool) ;
21862 0 : delete [] storageArray;
21863 0 : SgAsmStmtStorageClass :: writeEasyStorageDataToFile(out) ;
21864 : }
21865 :
21866 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssertStmt );
21867 3 : storageClassIndex = 0 ;
21868 3 : if ( 0 < sizeOfActualPool )
21869 : {
21870 0 : SgAssertStmtStorageClass* storageArray = new SgAssertStmtStorageClass[sizeOfActualPool] ;
21871 0 : storageClassIndex = SgAssertStmt::initializeStorageClassArray (storageArray); ;
21872 0 : assert ( storageClassIndex == sizeOfActualPool );
21873 0 : out.write ( (char*) (storageArray) , sizeof ( SgAssertStmtStorageClass ) * sizeOfActualPool) ;
21874 0 : delete [] storageArray;
21875 0 : SgAssertStmtStorageClass :: writeEasyStorageDataToFile(out) ;
21876 : }
21877 :
21878 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssignInitializer );
21879 3 : storageClassIndex = 0 ;
21880 3 : if ( 0 < sizeOfActualPool )
21881 : {
21882 1194 : SgAssignInitializerStorageClass* storageArray = new SgAssignInitializerStorageClass[sizeOfActualPool] ;
21883 1 : storageClassIndex = SgAssignInitializer::initializeStorageClassArray (storageArray); ;
21884 1 : assert ( storageClassIndex == sizeOfActualPool );
21885 1 : out.write ( (char*) (storageArray) , sizeof ( SgAssignInitializerStorageClass ) * sizeOfActualPool) ;
21886 1 : delete [] storageArray;
21887 1 : SgAssignInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
21888 : }
21889 :
21890 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssignOp );
21891 3 : storageClassIndex = 0 ;
21892 3 : if ( 0 < sizeOfActualPool )
21893 : {
21894 456 : SgAssignOpStorageClass* storageArray = new SgAssignOpStorageClass[sizeOfActualPool] ;
21895 1 : storageClassIndex = SgAssignOp::initializeStorageClassArray (storageArray); ;
21896 1 : assert ( storageClassIndex == sizeOfActualPool );
21897 1 : out.write ( (char*) (storageArray) , sizeof ( SgAssignOpStorageClass ) * sizeOfActualPool) ;
21898 1 : delete [] storageArray;
21899 1 : SgAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
21900 : }
21901 :
21902 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssignStatement );
21903 3 : storageClassIndex = 0 ;
21904 3 : if ( 0 < sizeOfActualPool )
21905 : {
21906 0 : SgAssignStatementStorageClass* storageArray = new SgAssignStatementStorageClass[sizeOfActualPool] ;
21907 0 : storageClassIndex = SgAssignStatement::initializeStorageClassArray (storageArray); ;
21908 0 : assert ( storageClassIndex == sizeOfActualPool );
21909 0 : out.write ( (char*) (storageArray) , sizeof ( SgAssignStatementStorageClass ) * sizeOfActualPool) ;
21910 0 : delete [] storageArray;
21911 0 : SgAssignStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21912 : }
21913 :
21914 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssignedGotoStatement );
21915 3 : storageClassIndex = 0 ;
21916 3 : if ( 0 < sizeOfActualPool )
21917 : {
21918 0 : SgAssignedGotoStatementStorageClass* storageArray = new SgAssignedGotoStatementStorageClass[sizeOfActualPool] ;
21919 0 : storageClassIndex = SgAssignedGotoStatement::initializeStorageClassArray (storageArray); ;
21920 0 : assert ( storageClassIndex == sizeOfActualPool );
21921 0 : out.write ( (char*) (storageArray) , sizeof ( SgAssignedGotoStatementStorageClass ) * sizeOfActualPool) ;
21922 0 : delete [] storageArray;
21923 0 : SgAssignedGotoStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21924 : }
21925 :
21926 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAssociateStatement );
21927 3 : storageClassIndex = 0 ;
21928 3 : if ( 0 < sizeOfActualPool )
21929 : {
21930 0 : SgAssociateStatementStorageClass* storageArray = new SgAssociateStatementStorageClass[sizeOfActualPool] ;
21931 0 : storageClassIndex = SgAssociateStatement::initializeStorageClassArray (storageArray); ;
21932 0 : assert ( storageClassIndex == sizeOfActualPool );
21933 0 : out.write ( (char*) (storageArray) , sizeof ( SgAssociateStatementStorageClass ) * sizeOfActualPool) ;
21934 0 : delete [] storageArray;
21935 0 : SgAssociateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21936 : }
21937 :
21938 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAsteriskShapeExp );
21939 3 : storageClassIndex = 0 ;
21940 3 : if ( 0 < sizeOfActualPool )
21941 : {
21942 2 : SgAsteriskShapeExpStorageClass* storageArray = new SgAsteriskShapeExpStorageClass[sizeOfActualPool] ;
21943 1 : storageClassIndex = SgAsteriskShapeExp::initializeStorageClassArray (storageArray); ;
21944 1 : assert ( storageClassIndex == sizeOfActualPool );
21945 1 : out.write ( (char*) (storageArray) , sizeof ( SgAsteriskShapeExpStorageClass ) * sizeOfActualPool) ;
21946 1 : delete [] storageArray;
21947 1 : SgAsteriskShapeExpStorageClass :: writeEasyStorageDataToFile(out) ;
21948 : }
21949 :
21950 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAttribute );
21951 3 : storageClassIndex = 0 ;
21952 3 : if ( 0 < sizeOfActualPool )
21953 : {
21954 0 : SgAttributeStorageClass* storageArray = new SgAttributeStorageClass[sizeOfActualPool] ;
21955 0 : storageClassIndex = SgAttribute::initializeStorageClassArray (storageArray); ;
21956 0 : assert ( storageClassIndex == sizeOfActualPool );
21957 0 : out.write ( (char*) (storageArray) , sizeof ( SgAttributeStorageClass ) * sizeOfActualPool) ;
21958 0 : delete [] storageArray;
21959 0 : SgAttributeStorageClass :: writeEasyStorageDataToFile(out) ;
21960 : }
21961 :
21962 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAttributeSpecificationStatement );
21963 3 : storageClassIndex = 0 ;
21964 3 : if ( 0 < sizeOfActualPool )
21965 : {
21966 0 : SgAttributeSpecificationStatementStorageClass* storageArray = new SgAttributeSpecificationStatementStorageClass[sizeOfActualPool] ;
21967 0 : storageClassIndex = SgAttributeSpecificationStatement::initializeStorageClassArray (storageArray); ;
21968 0 : assert ( storageClassIndex == sizeOfActualPool );
21969 0 : out.write ( (char*) (storageArray) , sizeof ( SgAttributeSpecificationStatementStorageClass ) * sizeOfActualPool) ;
21970 0 : delete [] storageArray;
21971 0 : SgAttributeSpecificationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
21972 : }
21973 :
21974 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAutoType );
21975 3 : storageClassIndex = 0 ;
21976 3 : if ( 0 < sizeOfActualPool )
21977 : {
21978 15 : SgAutoTypeStorageClass* storageArray = new SgAutoTypeStorageClass[sizeOfActualPool] ;
21979 1 : storageClassIndex = SgAutoType::initializeStorageClassArray (storageArray); ;
21980 1 : assert ( storageClassIndex == sizeOfActualPool );
21981 1 : out.write ( (char*) (storageArray) , sizeof ( SgAutoTypeStorageClass ) * sizeOfActualPool) ;
21982 1 : delete [] storageArray;
21983 1 : SgAutoTypeStorageClass :: writeEasyStorageDataToFile(out) ;
21984 : }
21985 :
21986 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAwaitExpression );
21987 3 : storageClassIndex = 0 ;
21988 3 : if ( 0 < sizeOfActualPool )
21989 : {
21990 0 : SgAwaitExpressionStorageClass* storageArray = new SgAwaitExpressionStorageClass[sizeOfActualPool] ;
21991 0 : storageClassIndex = SgAwaitExpression::initializeStorageClassArray (storageArray); ;
21992 0 : assert ( storageClassIndex == sizeOfActualPool );
21993 0 : out.write ( (char*) (storageArray) , sizeof ( SgAwaitExpressionStorageClass ) * sizeOfActualPool) ;
21994 0 : delete [] storageArray;
21995 0 : SgAwaitExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
21996 : }
21997 :
21998 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBackspaceStatement );
21999 3 : storageClassIndex = 0 ;
22000 3 : if ( 0 < sizeOfActualPool )
22001 : {
22002 0 : SgBackspaceStatementStorageClass* storageArray = new SgBackspaceStatementStorageClass[sizeOfActualPool] ;
22003 0 : storageClassIndex = SgBackspaceStatement::initializeStorageClassArray (storageArray); ;
22004 0 : assert ( storageClassIndex == sizeOfActualPool );
22005 0 : out.write ( (char*) (storageArray) , sizeof ( SgBackspaceStatementStorageClass ) * sizeOfActualPool) ;
22006 0 : delete [] storageArray;
22007 0 : SgBackspaceStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22008 : }
22009 :
22010 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBaseClass );
22011 3 : storageClassIndex = 0 ;
22012 3 : if ( 0 < sizeOfActualPool )
22013 : {
22014 1 : SgBaseClassStorageClass* storageArray = new SgBaseClassStorageClass[sizeOfActualPool] ;
22015 1 : storageClassIndex = SgBaseClass::initializeStorageClassArray (storageArray); ;
22016 1 : assert ( storageClassIndex == sizeOfActualPool );
22017 1 : out.write ( (char*) (storageArray) , sizeof ( SgBaseClassStorageClass ) * sizeOfActualPool) ;
22018 1 : delete [] storageArray;
22019 : }
22020 :
22021 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExpBaseClass );
22022 3 : storageClassIndex = 0 ;
22023 3 : if ( 0 < sizeOfActualPool )
22024 : {
22025 0 : SgExpBaseClassStorageClass* storageArray = new SgExpBaseClassStorageClass[sizeOfActualPool] ;
22026 0 : storageClassIndex = SgExpBaseClass::initializeStorageClassArray (storageArray); ;
22027 0 : assert ( storageClassIndex == sizeOfActualPool );
22028 0 : out.write ( (char*) (storageArray) , sizeof ( SgExpBaseClassStorageClass ) * sizeOfActualPool) ;
22029 0 : delete [] storageArray;
22030 : }
22031 :
22032 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBaseClassModifier );
22033 3 : storageClassIndex = 0 ;
22034 3 : if ( 0 < sizeOfActualPool )
22035 : {
22036 1 : SgBaseClassModifierStorageClass* storageArray = new SgBaseClassModifierStorageClass[sizeOfActualPool] ;
22037 1 : storageClassIndex = SgBaseClassModifier::initializeStorageClassArray (storageArray); ;
22038 1 : assert ( storageClassIndex == sizeOfActualPool );
22039 1 : out.write ( (char*) (storageArray) , sizeof ( SgBaseClassModifierStorageClass ) * sizeOfActualPool) ;
22040 1 : delete [] storageArray;
22041 1 : SgBaseClassModifierStorageClass :: writeEasyStorageDataToFile(out) ;
22042 : }
22043 :
22044 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBasicBlock );
22045 3 : storageClassIndex = 0 ;
22046 3 : if ( 0 < sizeOfActualPool )
22047 : {
22048 2869 : SgBasicBlockStorageClass* storageArray = new SgBasicBlockStorageClass[sizeOfActualPool] ;
22049 3 : storageClassIndex = SgBasicBlock::initializeStorageClassArray (storageArray); ;
22050 3 : assert ( storageClassIndex == sizeOfActualPool );
22051 3 : out.write ( (char*) (storageArray) , sizeof ( SgBasicBlockStorageClass ) * sizeOfActualPool) ;
22052 3 : delete [] storageArray;
22053 3 : SgBasicBlockStorageClass :: writeEasyStorageDataToFile(out) ;
22054 : }
22055 :
22056 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBidirectionalGraph );
22057 3 : storageClassIndex = 0 ;
22058 3 : if ( 0 < sizeOfActualPool )
22059 : {
22060 0 : SgBidirectionalGraphStorageClass* storageArray = new SgBidirectionalGraphStorageClass[sizeOfActualPool] ;
22061 0 : storageClassIndex = SgBidirectionalGraph::initializeStorageClassArray (storageArray); ;
22062 0 : assert ( storageClassIndex == sizeOfActualPool );
22063 0 : out.write ( (char*) (storageArray) , sizeof ( SgBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
22064 0 : delete [] storageArray;
22065 0 : SgBidirectionalGraphStorageClass :: writeEasyStorageDataToFile(out) ;
22066 : }
22067 :
22068 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBinaryOp );
22069 3 : storageClassIndex = 0 ;
22070 3 : if ( 0 < sizeOfActualPool )
22071 : {
22072 0 : SgBinaryOpStorageClass* storageArray = new SgBinaryOpStorageClass[sizeOfActualPool] ;
22073 0 : storageClassIndex = SgBinaryOp::initializeStorageClassArray (storageArray); ;
22074 0 : assert ( storageClassIndex == sizeOfActualPool );
22075 0 : out.write ( (char*) (storageArray) , sizeof ( SgBinaryOpStorageClass ) * sizeOfActualPool) ;
22076 0 : delete [] storageArray;
22077 0 : SgBinaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
22078 : }
22079 :
22080 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitAndOp );
22081 3 : storageClassIndex = 0 ;
22082 3 : if ( 0 < sizeOfActualPool )
22083 : {
22084 21 : SgBitAndOpStorageClass* storageArray = new SgBitAndOpStorageClass[sizeOfActualPool] ;
22085 1 : storageClassIndex = SgBitAndOp::initializeStorageClassArray (storageArray); ;
22086 1 : assert ( storageClassIndex == sizeOfActualPool );
22087 1 : out.write ( (char*) (storageArray) , sizeof ( SgBitAndOpStorageClass ) * sizeOfActualPool) ;
22088 1 : delete [] storageArray;
22089 1 : SgBitAndOpStorageClass :: writeEasyStorageDataToFile(out) ;
22090 : }
22091 :
22092 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitAttribute );
22093 3 : storageClassIndex = 0 ;
22094 3 : if ( 0 < sizeOfActualPool )
22095 : {
22096 0 : SgBitAttributeStorageClass* storageArray = new SgBitAttributeStorageClass[sizeOfActualPool] ;
22097 0 : storageClassIndex = SgBitAttribute::initializeStorageClassArray (storageArray); ;
22098 0 : assert ( storageClassIndex == sizeOfActualPool );
22099 0 : out.write ( (char*) (storageArray) , sizeof ( SgBitAttributeStorageClass ) * sizeOfActualPool) ;
22100 0 : delete [] storageArray;
22101 0 : SgBitAttributeStorageClass :: writeEasyStorageDataToFile(out) ;
22102 : }
22103 :
22104 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitComplementOp );
22105 3 : storageClassIndex = 0 ;
22106 3 : if ( 0 < sizeOfActualPool )
22107 : {
22108 12 : SgBitComplementOpStorageClass* storageArray = new SgBitComplementOpStorageClass[sizeOfActualPool] ;
22109 1 : storageClassIndex = SgBitComplementOp::initializeStorageClassArray (storageArray); ;
22110 1 : assert ( storageClassIndex == sizeOfActualPool );
22111 1 : out.write ( (char*) (storageArray) , sizeof ( SgBitComplementOpStorageClass ) * sizeOfActualPool) ;
22112 1 : delete [] storageArray;
22113 1 : SgBitComplementOpStorageClass :: writeEasyStorageDataToFile(out) ;
22114 : }
22115 :
22116 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitEqvOp );
22117 3 : storageClassIndex = 0 ;
22118 3 : if ( 0 < sizeOfActualPool )
22119 : {
22120 0 : SgBitEqvOpStorageClass* storageArray = new SgBitEqvOpStorageClass[sizeOfActualPool] ;
22121 0 : storageClassIndex = SgBitEqvOp::initializeStorageClassArray (storageArray); ;
22122 0 : assert ( storageClassIndex == sizeOfActualPool );
22123 0 : out.write ( (char*) (storageArray) , sizeof ( SgBitEqvOpStorageClass ) * sizeOfActualPool) ;
22124 0 : delete [] storageArray;
22125 0 : SgBitEqvOpStorageClass :: writeEasyStorageDataToFile(out) ;
22126 : }
22127 :
22128 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitOrOp );
22129 3 : storageClassIndex = 0 ;
22130 3 : if ( 0 < sizeOfActualPool )
22131 : {
22132 16 : SgBitOrOpStorageClass* storageArray = new SgBitOrOpStorageClass[sizeOfActualPool] ;
22133 1 : storageClassIndex = SgBitOrOp::initializeStorageClassArray (storageArray); ;
22134 1 : assert ( storageClassIndex == sizeOfActualPool );
22135 1 : out.write ( (char*) (storageArray) , sizeof ( SgBitOrOpStorageClass ) * sizeOfActualPool) ;
22136 1 : delete [] storageArray;
22137 1 : SgBitOrOpStorageClass :: writeEasyStorageDataToFile(out) ;
22138 : }
22139 :
22140 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBitXorOp );
22141 3 : storageClassIndex = 0 ;
22142 3 : if ( 0 < sizeOfActualPool )
22143 : {
22144 7 : SgBitXorOpStorageClass* storageArray = new SgBitXorOpStorageClass[sizeOfActualPool] ;
22145 1 : storageClassIndex = SgBitXorOp::initializeStorageClassArray (storageArray); ;
22146 1 : assert ( storageClassIndex == sizeOfActualPool );
22147 1 : out.write ( (char*) (storageArray) , sizeof ( SgBitXorOpStorageClass ) * sizeOfActualPool) ;
22148 1 : delete [] storageArray;
22149 1 : SgBitXorOpStorageClass :: writeEasyStorageDataToFile(out) ;
22150 : }
22151 :
22152 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBlockDataStatement );
22153 3 : storageClassIndex = 0 ;
22154 3 : if ( 0 < sizeOfActualPool )
22155 : {
22156 0 : SgBlockDataStatementStorageClass* storageArray = new SgBlockDataStatementStorageClass[sizeOfActualPool] ;
22157 0 : storageClassIndex = SgBlockDataStatement::initializeStorageClassArray (storageArray); ;
22158 0 : assert ( storageClassIndex == sizeOfActualPool );
22159 0 : out.write ( (char*) (storageArray) , sizeof ( SgBlockDataStatementStorageClass ) * sizeOfActualPool) ;
22160 0 : delete [] storageArray;
22161 0 : SgBlockDataStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22162 : }
22163 :
22164 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBoolValExp );
22165 3 : storageClassIndex = 0 ;
22166 3 : if ( 0 < sizeOfActualPool )
22167 : {
22168 399 : SgBoolValExpStorageClass* storageArray = new SgBoolValExpStorageClass[sizeOfActualPool] ;
22169 1 : storageClassIndex = SgBoolValExp::initializeStorageClassArray (storageArray); ;
22170 1 : assert ( storageClassIndex == sizeOfActualPool );
22171 1 : out.write ( (char*) (storageArray) , sizeof ( SgBoolValExpStorageClass ) * sizeOfActualPool) ;
22172 1 : delete [] storageArray;
22173 1 : SgBoolValExpStorageClass :: writeEasyStorageDataToFile(out) ;
22174 : }
22175 :
22176 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBreakStmt );
22177 3 : storageClassIndex = 0 ;
22178 3 : if ( 0 < sizeOfActualPool )
22179 : {
22180 31 : SgBreakStmtStorageClass* storageArray = new SgBreakStmtStorageClass[sizeOfActualPool] ;
22181 1 : storageClassIndex = SgBreakStmt::initializeStorageClassArray (storageArray); ;
22182 1 : assert ( storageClassIndex == sizeOfActualPool );
22183 1 : out.write ( (char*) (storageArray) , sizeof ( SgBreakStmtStorageClass ) * sizeOfActualPool) ;
22184 1 : delete [] storageArray;
22185 1 : SgBreakStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22186 : }
22187 :
22188 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgBracedInitializer );
22189 3 : storageClassIndex = 0 ;
22190 3 : if ( 0 < sizeOfActualPool )
22191 : {
22192 2 : SgBracedInitializerStorageClass* storageArray = new SgBracedInitializerStorageClass[sizeOfActualPool] ;
22193 1 : storageClassIndex = SgBracedInitializer::initializeStorageClassArray (storageArray); ;
22194 1 : assert ( storageClassIndex == sizeOfActualPool );
22195 1 : out.write ( (char*) (storageArray) , sizeof ( SgBracedInitializerStorageClass ) * sizeOfActualPool) ;
22196 1 : delete [] storageArray;
22197 1 : SgBracedInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
22198 : }
22199 :
22200 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgC_PreprocessorDirectiveStatement );
22201 3 : storageClassIndex = 0 ;
22202 3 : if ( 0 < sizeOfActualPool )
22203 : {
22204 0 : SgC_PreprocessorDirectiveStatementStorageClass* storageArray = new SgC_PreprocessorDirectiveStatementStorageClass[sizeOfActualPool] ;
22205 0 : storageClassIndex = SgC_PreprocessorDirectiveStatement::initializeStorageClassArray (storageArray); ;
22206 0 : assert ( storageClassIndex == sizeOfActualPool );
22207 0 : out.write ( (char*) (storageArray) , sizeof ( SgC_PreprocessorDirectiveStatementStorageClass ) * sizeOfActualPool) ;
22208 0 : delete [] storageArray;
22209 0 : SgC_PreprocessorDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22210 : }
22211 :
22212 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCaseOptionStmt );
22213 3 : storageClassIndex = 0 ;
22214 3 : if ( 0 < sizeOfActualPool )
22215 : {
22216 0 : SgCaseOptionStmtStorageClass* storageArray = new SgCaseOptionStmtStorageClass[sizeOfActualPool] ;
22217 0 : storageClassIndex = SgCaseOptionStmt::initializeStorageClassArray (storageArray); ;
22218 0 : assert ( storageClassIndex == sizeOfActualPool );
22219 0 : out.write ( (char*) (storageArray) , sizeof ( SgCaseOptionStmtStorageClass ) * sizeOfActualPool) ;
22220 0 : delete [] storageArray;
22221 0 : SgCaseOptionStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22222 : }
22223 :
22224 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCastExp );
22225 3 : storageClassIndex = 0 ;
22226 3 : if ( 0 < sizeOfActualPool )
22227 : {
22228 2263 : SgCastExpStorageClass* storageArray = new SgCastExpStorageClass[sizeOfActualPool] ;
22229 2 : storageClassIndex = SgCastExp::initializeStorageClassArray (storageArray); ;
22230 2 : assert ( storageClassIndex == sizeOfActualPool );
22231 2 : out.write ( (char*) (storageArray) , sizeof ( SgCastExpStorageClass ) * sizeOfActualPool) ;
22232 2 : delete [] storageArray;
22233 2 : SgCastExpStorageClass :: writeEasyStorageDataToFile(out) ;
22234 : }
22235 :
22236 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCatchOptionStmt );
22237 3 : storageClassIndex = 0 ;
22238 3 : if ( 0 < sizeOfActualPool )
22239 : {
22240 91 : SgCatchOptionStmtStorageClass* storageArray = new SgCatchOptionStmtStorageClass[sizeOfActualPool] ;
22241 1 : storageClassIndex = SgCatchOptionStmt::initializeStorageClassArray (storageArray); ;
22242 1 : assert ( storageClassIndex == sizeOfActualPool );
22243 1 : out.write ( (char*) (storageArray) , sizeof ( SgCatchOptionStmtStorageClass ) * sizeOfActualPool) ;
22244 1 : delete [] storageArray;
22245 1 : SgCatchOptionStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22246 : }
22247 :
22248 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCatchStatementSeq );
22249 3 : storageClassIndex = 0 ;
22250 3 : if ( 0 < sizeOfActualPool )
22251 : {
22252 55 : SgCatchStatementSeqStorageClass* storageArray = new SgCatchStatementSeqStorageClass[sizeOfActualPool] ;
22253 1 : storageClassIndex = SgCatchStatementSeq::initializeStorageClassArray (storageArray); ;
22254 1 : assert ( storageClassIndex == sizeOfActualPool );
22255 1 : out.write ( (char*) (storageArray) , sizeof ( SgCatchStatementSeqStorageClass ) * sizeOfActualPool) ;
22256 1 : delete [] storageArray;
22257 1 : SgCatchStatementSeqStorageClass :: writeEasyStorageDataToFile(out) ;
22258 : }
22259 :
22260 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCharVal );
22261 3 : storageClassIndex = 0 ;
22262 3 : if ( 0 < sizeOfActualPool )
22263 : {
22264 48 : SgCharValStorageClass* storageArray = new SgCharValStorageClass[sizeOfActualPool] ;
22265 1 : storageClassIndex = SgCharVal::initializeStorageClassArray (storageArray); ;
22266 1 : assert ( storageClassIndex == sizeOfActualPool );
22267 1 : out.write ( (char*) (storageArray) , sizeof ( SgCharValStorageClass ) * sizeOfActualPool) ;
22268 1 : delete [] storageArray;
22269 1 : SgCharValStorageClass :: writeEasyStorageDataToFile(out) ;
22270 : }
22271 :
22272 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgChar16Val );
22273 3 : storageClassIndex = 0 ;
22274 3 : if ( 0 < sizeOfActualPool )
22275 : {
22276 0 : SgChar16ValStorageClass* storageArray = new SgChar16ValStorageClass[sizeOfActualPool] ;
22277 0 : storageClassIndex = SgChar16Val::initializeStorageClassArray (storageArray); ;
22278 0 : assert ( storageClassIndex == sizeOfActualPool );
22279 0 : out.write ( (char*) (storageArray) , sizeof ( SgChar16ValStorageClass ) * sizeOfActualPool) ;
22280 0 : delete [] storageArray;
22281 0 : SgChar16ValStorageClass :: writeEasyStorageDataToFile(out) ;
22282 : }
22283 :
22284 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgChar32Val );
22285 3 : storageClassIndex = 0 ;
22286 3 : if ( 0 < sizeOfActualPool )
22287 : {
22288 0 : SgChar32ValStorageClass* storageArray = new SgChar32ValStorageClass[sizeOfActualPool] ;
22289 0 : storageClassIndex = SgChar32Val::initializeStorageClassArray (storageArray); ;
22290 0 : assert ( storageClassIndex == sizeOfActualPool );
22291 0 : out.write ( (char*) (storageArray) , sizeof ( SgChar32ValStorageClass ) * sizeOfActualPool) ;
22292 0 : delete [] storageArray;
22293 0 : SgChar32ValStorageClass :: writeEasyStorageDataToFile(out) ;
22294 : }
22295 :
22296 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgChooseExpression );
22297 3 : storageClassIndex = 0 ;
22298 3 : if ( 0 < sizeOfActualPool )
22299 : {
22300 0 : SgChooseExpressionStorageClass* storageArray = new SgChooseExpressionStorageClass[sizeOfActualPool] ;
22301 0 : storageClassIndex = SgChooseExpression::initializeStorageClassArray (storageArray); ;
22302 0 : assert ( storageClassIndex == sizeOfActualPool );
22303 0 : out.write ( (char*) (storageArray) , sizeof ( SgChooseExpressionStorageClass ) * sizeOfActualPool) ;
22304 0 : delete [] storageArray;
22305 0 : SgChooseExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
22306 : }
22307 :
22308 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassDecl_attr );
22309 3 : storageClassIndex = 0 ;
22310 3 : if ( 0 < sizeOfActualPool )
22311 : {
22312 0 : SgClassDecl_attrStorageClass* storageArray = new SgClassDecl_attrStorageClass[sizeOfActualPool] ;
22313 0 : storageClassIndex = SgClassDecl_attr::initializeStorageClassArray (storageArray); ;
22314 0 : assert ( storageClassIndex == sizeOfActualPool );
22315 0 : out.write ( (char*) (storageArray) , sizeof ( SgClassDecl_attrStorageClass ) * sizeOfActualPool) ;
22316 0 : delete [] storageArray;
22317 0 : SgClassDecl_attrStorageClass :: writeEasyStorageDataToFile(out) ;
22318 : }
22319 :
22320 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassDeclaration );
22321 3 : storageClassIndex = 0 ;
22322 3 : if ( 0 < sizeOfActualPool )
22323 : {
22324 373 : SgClassDeclarationStorageClass* storageArray = new SgClassDeclarationStorageClass[sizeOfActualPool] ;
22325 2 : storageClassIndex = SgClassDeclaration::initializeStorageClassArray (storageArray); ;
22326 2 : assert ( storageClassIndex == sizeOfActualPool );
22327 2 : out.write ( (char*) (storageArray) , sizeof ( SgClassDeclarationStorageClass ) * sizeOfActualPool) ;
22328 2 : delete [] storageArray;
22329 2 : SgClassDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
22330 : }
22331 :
22332 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassDefinition );
22333 3 : storageClassIndex = 0 ;
22334 3 : if ( 0 < sizeOfActualPool )
22335 : {
22336 170 : SgClassDefinitionStorageClass* storageArray = new SgClassDefinitionStorageClass[sizeOfActualPool] ;
22337 2 : storageClassIndex = SgClassDefinition::initializeStorageClassArray (storageArray); ;
22338 2 : assert ( storageClassIndex == sizeOfActualPool );
22339 2 : out.write ( (char*) (storageArray) , sizeof ( SgClassDefinitionStorageClass ) * sizeOfActualPool) ;
22340 2 : delete [] storageArray;
22341 2 : SgClassDefinitionStorageClass :: writeEasyStorageDataToFile(out) ;
22342 : }
22343 :
22344 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassNameRefExp );
22345 3 : storageClassIndex = 0 ;
22346 3 : if ( 0 < sizeOfActualPool )
22347 : {
22348 0 : SgClassNameRefExpStorageClass* storageArray = new SgClassNameRefExpStorageClass[sizeOfActualPool] ;
22349 0 : storageClassIndex = SgClassNameRefExp::initializeStorageClassArray (storageArray); ;
22350 0 : assert ( storageClassIndex == sizeOfActualPool );
22351 0 : out.write ( (char*) (storageArray) , sizeof ( SgClassNameRefExpStorageClass ) * sizeOfActualPool) ;
22352 0 : delete [] storageArray;
22353 0 : SgClassNameRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
22354 : }
22355 :
22356 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassSymbol );
22357 3 : storageClassIndex = 0 ;
22358 3 : if ( 0 < sizeOfActualPool )
22359 : {
22360 854 : SgClassSymbolStorageClass* storageArray = new SgClassSymbolStorageClass[sizeOfActualPool] ;
22361 2 : storageClassIndex = SgClassSymbol::initializeStorageClassArray (storageArray); ;
22362 2 : assert ( storageClassIndex == sizeOfActualPool );
22363 2 : out.write ( (char*) (storageArray) , sizeof ( SgClassSymbolStorageClass ) * sizeOfActualPool) ;
22364 2 : delete [] storageArray;
22365 2 : SgClassSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
22366 : }
22367 :
22368 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassType );
22369 3 : storageClassIndex = 0 ;
22370 3 : if ( 0 < sizeOfActualPool )
22371 : {
22372 1403 : SgClassTypeStorageClass* storageArray = new SgClassTypeStorageClass[sizeOfActualPool] ;
22373 2 : storageClassIndex = SgClassType::initializeStorageClassArray (storageArray); ;
22374 2 : assert ( storageClassIndex == sizeOfActualPool );
22375 2 : out.write ( (char*) (storageArray) , sizeof ( SgClassTypeStorageClass ) * sizeOfActualPool) ;
22376 2 : delete [] storageArray;
22377 2 : SgClassTypeStorageClass :: writeEasyStorageDataToFile(out) ;
22378 : }
22379 :
22380 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClinkageDeclarationStatement );
22381 3 : storageClassIndex = 0 ;
22382 3 : if ( 0 < sizeOfActualPool )
22383 : {
22384 0 : SgClinkageDeclarationStatementStorageClass* storageArray = new SgClinkageDeclarationStatementStorageClass[sizeOfActualPool] ;
22385 0 : storageClassIndex = SgClinkageDeclarationStatement::initializeStorageClassArray (storageArray); ;
22386 0 : assert ( storageClassIndex == sizeOfActualPool );
22387 0 : out.write ( (char*) (storageArray) , sizeof ( SgClinkageDeclarationStatementStorageClass ) * sizeOfActualPool) ;
22388 0 : delete [] storageArray;
22389 0 : SgClinkageDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22390 : }
22391 :
22392 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClinkageEndStatement );
22393 3 : storageClassIndex = 0 ;
22394 3 : if ( 0 < sizeOfActualPool )
22395 : {
22396 0 : SgClinkageEndStatementStorageClass* storageArray = new SgClinkageEndStatementStorageClass[sizeOfActualPool] ;
22397 0 : storageClassIndex = SgClinkageEndStatement::initializeStorageClassArray (storageArray); ;
22398 0 : assert ( storageClassIndex == sizeOfActualPool );
22399 0 : out.write ( (char*) (storageArray) , sizeof ( SgClinkageEndStatementStorageClass ) * sizeOfActualPool) ;
22400 0 : delete [] storageArray;
22401 0 : SgClinkageEndStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22402 : }
22403 :
22404 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClinkageStartStatement );
22405 3 : storageClassIndex = 0 ;
22406 3 : if ( 0 < sizeOfActualPool )
22407 : {
22408 0 : SgClinkageStartStatementStorageClass* storageArray = new SgClinkageStartStatementStorageClass[sizeOfActualPool] ;
22409 0 : storageClassIndex = SgClinkageStartStatement::initializeStorageClassArray (storageArray); ;
22410 0 : assert ( storageClassIndex == sizeOfActualPool );
22411 0 : out.write ( (char*) (storageArray) , sizeof ( SgClinkageStartStatementStorageClass ) * sizeOfActualPool) ;
22412 0 : delete [] storageArray;
22413 0 : SgClinkageStartStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22414 : }
22415 :
22416 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCloseStatement );
22417 3 : storageClassIndex = 0 ;
22418 3 : if ( 0 < sizeOfActualPool )
22419 : {
22420 0 : SgCloseStatementStorageClass* storageArray = new SgCloseStatementStorageClass[sizeOfActualPool] ;
22421 0 : storageClassIndex = SgCloseStatement::initializeStorageClassArray (storageArray); ;
22422 0 : assert ( storageClassIndex == sizeOfActualPool );
22423 0 : out.write ( (char*) (storageArray) , sizeof ( SgCloseStatementStorageClass ) * sizeOfActualPool) ;
22424 0 : delete [] storageArray;
22425 0 : SgCloseStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22426 : }
22427 :
22428 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgColonShapeExp );
22429 3 : storageClassIndex = 0 ;
22430 3 : if ( 0 < sizeOfActualPool )
22431 : {
22432 0 : SgColonShapeExpStorageClass* storageArray = new SgColonShapeExpStorageClass[sizeOfActualPool] ;
22433 0 : storageClassIndex = SgColonShapeExp::initializeStorageClassArray (storageArray); ;
22434 0 : assert ( storageClassIndex == sizeOfActualPool );
22435 0 : out.write ( (char*) (storageArray) , sizeof ( SgColonShapeExpStorageClass ) * sizeOfActualPool) ;
22436 0 : delete [] storageArray;
22437 0 : SgColonShapeExpStorageClass :: writeEasyStorageDataToFile(out) ;
22438 : }
22439 :
22440 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCommaOpExp );
22441 3 : storageClassIndex = 0 ;
22442 3 : if ( 0 < sizeOfActualPool )
22443 : {
22444 17 : SgCommaOpExpStorageClass* storageArray = new SgCommaOpExpStorageClass[sizeOfActualPool] ;
22445 1 : storageClassIndex = SgCommaOpExp::initializeStorageClassArray (storageArray); ;
22446 1 : assert ( storageClassIndex == sizeOfActualPool );
22447 1 : out.write ( (char*) (storageArray) , sizeof ( SgCommaOpExpStorageClass ) * sizeOfActualPool) ;
22448 1 : delete [] storageArray;
22449 1 : SgCommaOpExpStorageClass :: writeEasyStorageDataToFile(out) ;
22450 : }
22451 :
22452 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCommonBlock );
22453 3 : storageClassIndex = 0 ;
22454 3 : if ( 0 < sizeOfActualPool )
22455 : {
22456 0 : SgCommonBlockStorageClass* storageArray = new SgCommonBlockStorageClass[sizeOfActualPool] ;
22457 0 : storageClassIndex = SgCommonBlock::initializeStorageClassArray (storageArray); ;
22458 0 : assert ( storageClassIndex == sizeOfActualPool );
22459 0 : out.write ( (char*) (storageArray) , sizeof ( SgCommonBlockStorageClass ) * sizeOfActualPool) ;
22460 0 : delete [] storageArray;
22461 0 : SgCommonBlockStorageClass :: writeEasyStorageDataToFile(out) ;
22462 : }
22463 :
22464 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCommonBlockObject );
22465 3 : storageClassIndex = 0 ;
22466 3 : if ( 0 < sizeOfActualPool )
22467 : {
22468 0 : SgCommonBlockObjectStorageClass* storageArray = new SgCommonBlockObjectStorageClass[sizeOfActualPool] ;
22469 0 : storageClassIndex = SgCommonBlockObject::initializeStorageClassArray (storageArray); ;
22470 0 : assert ( storageClassIndex == sizeOfActualPool );
22471 0 : out.write ( (char*) (storageArray) , sizeof ( SgCommonBlockObjectStorageClass ) * sizeOfActualPool) ;
22472 0 : delete [] storageArray;
22473 0 : SgCommonBlockObjectStorageClass :: writeEasyStorageDataToFile(out) ;
22474 : }
22475 :
22476 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCommonSymbol );
22477 3 : storageClassIndex = 0 ;
22478 3 : if ( 0 < sizeOfActualPool )
22479 : {
22480 0 : SgCommonSymbolStorageClass* storageArray = new SgCommonSymbolStorageClass[sizeOfActualPool] ;
22481 0 : storageClassIndex = SgCommonSymbol::initializeStorageClassArray (storageArray); ;
22482 0 : assert ( storageClassIndex == sizeOfActualPool );
22483 0 : out.write ( (char*) (storageArray) , sizeof ( SgCommonSymbolStorageClass ) * sizeOfActualPool) ;
22484 0 : delete [] storageArray;
22485 0 : SgCommonSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
22486 : }
22487 :
22488 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgComplexVal );
22489 3 : storageClassIndex = 0 ;
22490 3 : if ( 0 < sizeOfActualPool )
22491 : {
22492 0 : SgComplexValStorageClass* storageArray = new SgComplexValStorageClass[sizeOfActualPool] ;
22493 0 : storageClassIndex = SgComplexVal::initializeStorageClassArray (storageArray); ;
22494 0 : assert ( storageClassIndex == sizeOfActualPool );
22495 0 : out.write ( (char*) (storageArray) , sizeof ( SgComplexValStorageClass ) * sizeOfActualPool) ;
22496 0 : delete [] storageArray;
22497 0 : SgComplexValStorageClass :: writeEasyStorageDataToFile(out) ;
22498 : }
22499 :
22500 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgComprehension );
22501 3 : storageClassIndex = 0 ;
22502 3 : if ( 0 < sizeOfActualPool )
22503 : {
22504 0 : SgComprehensionStorageClass* storageArray = new SgComprehensionStorageClass[sizeOfActualPool] ;
22505 0 : storageClassIndex = SgComprehension::initializeStorageClassArray (storageArray); ;
22506 0 : assert ( storageClassIndex == sizeOfActualPool );
22507 0 : out.write ( (char*) (storageArray) , sizeof ( SgComprehensionStorageClass ) * sizeOfActualPool) ;
22508 0 : delete [] storageArray;
22509 0 : SgComprehensionStorageClass :: writeEasyStorageDataToFile(out) ;
22510 : }
22511 :
22512 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCompoundAssignOp );
22513 3 : storageClassIndex = 0 ;
22514 3 : if ( 0 < sizeOfActualPool )
22515 : {
22516 0 : SgCompoundAssignOpStorageClass* storageArray = new SgCompoundAssignOpStorageClass[sizeOfActualPool] ;
22517 0 : storageClassIndex = SgCompoundAssignOp::initializeStorageClassArray (storageArray); ;
22518 0 : assert ( storageClassIndex == sizeOfActualPool );
22519 0 : out.write ( (char*) (storageArray) , sizeof ( SgCompoundAssignOpStorageClass ) * sizeOfActualPool) ;
22520 0 : delete [] storageArray;
22521 0 : SgCompoundAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
22522 : }
22523 :
22524 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCompoundInitializer );
22525 3 : storageClassIndex = 0 ;
22526 3 : if ( 0 < sizeOfActualPool )
22527 : {
22528 0 : SgCompoundInitializerStorageClass* storageArray = new SgCompoundInitializerStorageClass[sizeOfActualPool] ;
22529 0 : storageClassIndex = SgCompoundInitializer::initializeStorageClassArray (storageArray); ;
22530 0 : assert ( storageClassIndex == sizeOfActualPool );
22531 0 : out.write ( (char*) (storageArray) , sizeof ( SgCompoundInitializerStorageClass ) * sizeOfActualPool) ;
22532 0 : delete [] storageArray;
22533 0 : SgCompoundInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
22534 : }
22535 :
22536 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCompoundLiteralExp );
22537 3 : storageClassIndex = 0 ;
22538 3 : if ( 0 < sizeOfActualPool )
22539 : {
22540 0 : SgCompoundLiteralExpStorageClass* storageArray = new SgCompoundLiteralExpStorageClass[sizeOfActualPool] ;
22541 0 : storageClassIndex = SgCompoundLiteralExp::initializeStorageClassArray (storageArray); ;
22542 0 : assert ( storageClassIndex == sizeOfActualPool );
22543 0 : out.write ( (char*) (storageArray) , sizeof ( SgCompoundLiteralExpStorageClass ) * sizeOfActualPool) ;
22544 0 : delete [] storageArray;
22545 0 : SgCompoundLiteralExpStorageClass :: writeEasyStorageDataToFile(out) ;
22546 : }
22547 :
22548 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgComputedGotoStatement );
22549 3 : storageClassIndex = 0 ;
22550 3 : if ( 0 < sizeOfActualPool )
22551 : {
22552 0 : SgComputedGotoStatementStorageClass* storageArray = new SgComputedGotoStatementStorageClass[sizeOfActualPool] ;
22553 0 : storageClassIndex = SgComputedGotoStatement::initializeStorageClassArray (storageArray); ;
22554 0 : assert ( storageClassIndex == sizeOfActualPool );
22555 0 : out.write ( (char*) (storageArray) , sizeof ( SgComputedGotoStatementStorageClass ) * sizeOfActualPool) ;
22556 0 : delete [] storageArray;
22557 0 : SgComputedGotoStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22558 : }
22559 :
22560 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgConcatenationOp );
22561 3 : storageClassIndex = 0 ;
22562 3 : if ( 0 < sizeOfActualPool )
22563 : {
22564 0 : SgConcatenationOpStorageClass* storageArray = new SgConcatenationOpStorageClass[sizeOfActualPool] ;
22565 0 : storageClassIndex = SgConcatenationOp::initializeStorageClassArray (storageArray); ;
22566 0 : assert ( storageClassIndex == sizeOfActualPool );
22567 0 : out.write ( (char*) (storageArray) , sizeof ( SgConcatenationOpStorageClass ) * sizeOfActualPool) ;
22568 0 : delete [] storageArray;
22569 0 : SgConcatenationOpStorageClass :: writeEasyStorageDataToFile(out) ;
22570 : }
22571 :
22572 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgConditionalExp );
22573 3 : storageClassIndex = 0 ;
22574 3 : if ( 0 < sizeOfActualPool )
22575 : {
22576 72 : SgConditionalExpStorageClass* storageArray = new SgConditionalExpStorageClass[sizeOfActualPool] ;
22577 1 : storageClassIndex = SgConditionalExp::initializeStorageClassArray (storageArray); ;
22578 1 : assert ( storageClassIndex == sizeOfActualPool );
22579 1 : out.write ( (char*) (storageArray) , sizeof ( SgConditionalExpStorageClass ) * sizeOfActualPool) ;
22580 1 : delete [] storageArray;
22581 1 : SgConditionalExpStorageClass :: writeEasyStorageDataToFile(out) ;
22582 : }
22583 :
22584 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgConjugateOp );
22585 3 : storageClassIndex = 0 ;
22586 3 : if ( 0 < sizeOfActualPool )
22587 : {
22588 0 : SgConjugateOpStorageClass* storageArray = new SgConjugateOpStorageClass[sizeOfActualPool] ;
22589 0 : storageClassIndex = SgConjugateOp::initializeStorageClassArray (storageArray); ;
22590 0 : assert ( storageClassIndex == sizeOfActualPool );
22591 0 : out.write ( (char*) (storageArray) , sizeof ( SgConjugateOpStorageClass ) * sizeOfActualPool) ;
22592 0 : delete [] storageArray;
22593 0 : SgConjugateOpStorageClass :: writeEasyStorageDataToFile(out) ;
22594 : }
22595 :
22596 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgConstVolatileModifier );
22597 3 : storageClassIndex = 0 ;
22598 3 : if ( 0 < sizeOfActualPool )
22599 : {
22600 0 : SgConstVolatileModifierStorageClass* storageArray = new SgConstVolatileModifierStorageClass[sizeOfActualPool] ;
22601 0 : storageClassIndex = SgConstVolatileModifier::initializeStorageClassArray (storageArray); ;
22602 0 : assert ( storageClassIndex == sizeOfActualPool );
22603 0 : out.write ( (char*) (storageArray) , sizeof ( SgConstVolatileModifierStorageClass ) * sizeOfActualPool) ;
22604 0 : delete [] storageArray;
22605 : }
22606 :
22607 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgConstructorInitializer );
22608 3 : storageClassIndex = 0 ;
22609 3 : if ( 0 < sizeOfActualPool )
22610 : {
22611 462 : SgConstructorInitializerStorageClass* storageArray = new SgConstructorInitializerStorageClass[sizeOfActualPool] ;
22612 1 : storageClassIndex = SgConstructorInitializer::initializeStorageClassArray (storageArray); ;
22613 1 : assert ( storageClassIndex == sizeOfActualPool );
22614 1 : out.write ( (char*) (storageArray) , sizeof ( SgConstructorInitializerStorageClass ) * sizeOfActualPool) ;
22615 1 : delete [] storageArray;
22616 1 : SgConstructorInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
22617 : }
22618 :
22619 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgContainsStatement );
22620 3 : storageClassIndex = 0 ;
22621 3 : if ( 0 < sizeOfActualPool )
22622 : {
22623 0 : SgContainsStatementStorageClass* storageArray = new SgContainsStatementStorageClass[sizeOfActualPool] ;
22624 0 : storageClassIndex = SgContainsStatement::initializeStorageClassArray (storageArray); ;
22625 0 : assert ( storageClassIndex == sizeOfActualPool );
22626 0 : out.write ( (char*) (storageArray) , sizeof ( SgContainsStatementStorageClass ) * sizeOfActualPool) ;
22627 0 : delete [] storageArray;
22628 0 : SgContainsStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22629 : }
22630 :
22631 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgContinueStmt );
22632 3 : storageClassIndex = 0 ;
22633 3 : if ( 0 < sizeOfActualPool )
22634 : {
22635 3 : SgContinueStmtStorageClass* storageArray = new SgContinueStmtStorageClass[sizeOfActualPool] ;
22636 1 : storageClassIndex = SgContinueStmt::initializeStorageClassArray (storageArray); ;
22637 1 : assert ( storageClassIndex == sizeOfActualPool );
22638 1 : out.write ( (char*) (storageArray) , sizeof ( SgContinueStmtStorageClass ) * sizeOfActualPool) ;
22639 1 : delete [] storageArray;
22640 1 : SgContinueStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22641 : }
22642 :
22643 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCtorInitializerList );
22644 3 : storageClassIndex = 0 ;
22645 3 : if ( 0 < sizeOfActualPool )
22646 : {
22647 4429 : SgCtorInitializerListStorageClass* storageArray = new SgCtorInitializerListStorageClass[sizeOfActualPool] ;
22648 1 : storageClassIndex = SgCtorInitializerList::initializeStorageClassArray (storageArray); ;
22649 1 : assert ( storageClassIndex == sizeOfActualPool );
22650 1 : out.write ( (char*) (storageArray) , sizeof ( SgCtorInitializerListStorageClass ) * sizeOfActualPool) ;
22651 1 : delete [] storageArray;
22652 1 : SgCtorInitializerListStorageClass :: writeEasyStorageDataToFile(out) ;
22653 : }
22654 :
22655 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDataStatementGroup );
22656 3 : storageClassIndex = 0 ;
22657 3 : if ( 0 < sizeOfActualPool )
22658 : {
22659 0 : SgDataStatementGroupStorageClass* storageArray = new SgDataStatementGroupStorageClass[sizeOfActualPool] ;
22660 0 : storageClassIndex = SgDataStatementGroup::initializeStorageClassArray (storageArray); ;
22661 0 : assert ( storageClassIndex == sizeOfActualPool );
22662 0 : out.write ( (char*) (storageArray) , sizeof ( SgDataStatementGroupStorageClass ) * sizeOfActualPool) ;
22663 0 : delete [] storageArray;
22664 0 : SgDataStatementGroupStorageClass :: writeEasyStorageDataToFile(out) ;
22665 : }
22666 :
22667 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDataStatementObject );
22668 3 : storageClassIndex = 0 ;
22669 3 : if ( 0 < sizeOfActualPool )
22670 : {
22671 0 : SgDataStatementObjectStorageClass* storageArray = new SgDataStatementObjectStorageClass[sizeOfActualPool] ;
22672 0 : storageClassIndex = SgDataStatementObject::initializeStorageClassArray (storageArray); ;
22673 0 : assert ( storageClassIndex == sizeOfActualPool );
22674 0 : out.write ( (char*) (storageArray) , sizeof ( SgDataStatementObjectStorageClass ) * sizeOfActualPool) ;
22675 0 : delete [] storageArray;
22676 : }
22677 :
22678 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDataStatementValue );
22679 3 : storageClassIndex = 0 ;
22680 3 : if ( 0 < sizeOfActualPool )
22681 : {
22682 0 : SgDataStatementValueStorageClass* storageArray = new SgDataStatementValueStorageClass[sizeOfActualPool] ;
22683 0 : storageClassIndex = SgDataStatementValue::initializeStorageClassArray (storageArray); ;
22684 0 : assert ( storageClassIndex == sizeOfActualPool );
22685 0 : out.write ( (char*) (storageArray) , sizeof ( SgDataStatementValueStorageClass ) * sizeOfActualPool) ;
22686 0 : delete [] storageArray;
22687 : }
22688 :
22689 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeadIfDirectiveStatement );
22690 3 : storageClassIndex = 0 ;
22691 3 : if ( 0 < sizeOfActualPool )
22692 : {
22693 0 : SgDeadIfDirectiveStatementStorageClass* storageArray = new SgDeadIfDirectiveStatementStorageClass[sizeOfActualPool] ;
22694 0 : storageClassIndex = SgDeadIfDirectiveStatement::initializeStorageClassArray (storageArray); ;
22695 0 : assert ( storageClassIndex == sizeOfActualPool );
22696 0 : out.write ( (char*) (storageArray) , sizeof ( SgDeadIfDirectiveStatementStorageClass ) * sizeOfActualPool) ;
22697 0 : delete [] storageArray;
22698 0 : SgDeadIfDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22699 : }
22700 :
22701 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeallocateStatement );
22702 3 : storageClassIndex = 0 ;
22703 3 : if ( 0 < sizeOfActualPool )
22704 : {
22705 0 : SgDeallocateStatementStorageClass* storageArray = new SgDeallocateStatementStorageClass[sizeOfActualPool] ;
22706 0 : storageClassIndex = SgDeallocateStatement::initializeStorageClassArray (storageArray); ;
22707 0 : assert ( storageClassIndex == sizeOfActualPool );
22708 0 : out.write ( (char*) (storageArray) , sizeof ( SgDeallocateStatementStorageClass ) * sizeOfActualPool) ;
22709 0 : delete [] storageArray;
22710 0 : SgDeallocateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22711 : }
22712 :
22713 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeclarationModifier );
22714 3 : storageClassIndex = 0 ;
22715 3 : if ( 0 < sizeOfActualPool )
22716 : {
22717 0 : SgDeclarationModifierStorageClass* storageArray = new SgDeclarationModifierStorageClass[sizeOfActualPool] ;
22718 0 : storageClassIndex = SgDeclarationModifier::initializeStorageClassArray (storageArray); ;
22719 0 : assert ( storageClassIndex == sizeOfActualPool );
22720 0 : out.write ( (char*) (storageArray) , sizeof ( SgDeclarationModifierStorageClass ) * sizeOfActualPool) ;
22721 0 : delete [] storageArray;
22722 0 : SgDeclarationModifierStorageClass :: writeEasyStorageDataToFile(out) ;
22723 : }
22724 :
22725 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeclarationScope );
22726 3 : storageClassIndex = 0 ;
22727 3 : if ( 0 < sizeOfActualPool )
22728 : {
22729 6497 : SgDeclarationScopeStorageClass* storageArray = new SgDeclarationScopeStorageClass[sizeOfActualPool] ;
22730 1 : storageClassIndex = SgDeclarationScope::initializeStorageClassArray (storageArray); ;
22731 1 : assert ( storageClassIndex == sizeOfActualPool );
22732 1 : out.write ( (char*) (storageArray) , sizeof ( SgDeclarationScopeStorageClass ) * sizeOfActualPool) ;
22733 1 : delete [] storageArray;
22734 1 : SgDeclarationScopeStorageClass :: writeEasyStorageDataToFile(out) ;
22735 : }
22736 :
22737 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeclarationStatement );
22738 3 : storageClassIndex = 0 ;
22739 3 : if ( 0 < sizeOfActualPool )
22740 : {
22741 0 : SgDeclarationStatementStorageClass* storageArray = new SgDeclarationStatementStorageClass[sizeOfActualPool] ;
22742 0 : storageClassIndex = SgDeclarationStatement::initializeStorageClassArray (storageArray); ;
22743 0 : assert ( storageClassIndex == sizeOfActualPool );
22744 0 : out.write ( (char*) (storageArray) , sizeof ( SgDeclarationStatementStorageClass ) * sizeOfActualPool) ;
22745 0 : delete [] storageArray;
22746 0 : SgDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22747 : }
22748 :
22749 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeclType );
22750 3 : storageClassIndex = 0 ;
22751 3 : if ( 0 < sizeOfActualPool )
22752 : {
22753 93 : SgDeclTypeStorageClass* storageArray = new SgDeclTypeStorageClass[sizeOfActualPool] ;
22754 1 : storageClassIndex = SgDeclType::initializeStorageClassArray (storageArray); ;
22755 1 : assert ( storageClassIndex == sizeOfActualPool );
22756 1 : out.write ( (char*) (storageArray) , sizeof ( SgDeclTypeStorageClass ) * sizeOfActualPool) ;
22757 1 : delete [] storageArray;
22758 1 : SgDeclTypeStorageClass :: writeEasyStorageDataToFile(out) ;
22759 : }
22760 :
22761 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDefaultOptionStmt );
22762 3 : storageClassIndex = 0 ;
22763 3 : if ( 0 < sizeOfActualPool )
22764 : {
22765 0 : SgDefaultOptionStmtStorageClass* storageArray = new SgDefaultOptionStmtStorageClass[sizeOfActualPool] ;
22766 0 : storageClassIndex = SgDefaultOptionStmt::initializeStorageClassArray (storageArray); ;
22767 0 : assert ( storageClassIndex == sizeOfActualPool );
22768 0 : out.write ( (char*) (storageArray) , sizeof ( SgDefaultOptionStmtStorageClass ) * sizeOfActualPool) ;
22769 0 : delete [] storageArray;
22770 0 : SgDefaultOptionStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22771 : }
22772 :
22773 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDefaultSymbol );
22774 3 : storageClassIndex = 0 ;
22775 3 : if ( 0 < sizeOfActualPool )
22776 : {
22777 0 : SgDefaultSymbolStorageClass* storageArray = new SgDefaultSymbolStorageClass[sizeOfActualPool] ;
22778 0 : storageClassIndex = SgDefaultSymbol::initializeStorageClassArray (storageArray); ;
22779 0 : assert ( storageClassIndex == sizeOfActualPool );
22780 0 : out.write ( (char*) (storageArray) , sizeof ( SgDefaultSymbolStorageClass ) * sizeOfActualPool) ;
22781 0 : delete [] storageArray;
22782 0 : SgDefaultSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
22783 : }
22784 :
22785 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDefineDirectiveStatement );
22786 3 : storageClassIndex = 0 ;
22787 3 : if ( 0 < sizeOfActualPool )
22788 : {
22789 0 : SgDefineDirectiveStatementStorageClass* storageArray = new SgDefineDirectiveStatementStorageClass[sizeOfActualPool] ;
22790 0 : storageClassIndex = SgDefineDirectiveStatement::initializeStorageClassArray (storageArray); ;
22791 0 : assert ( storageClassIndex == sizeOfActualPool );
22792 0 : out.write ( (char*) (storageArray) , sizeof ( SgDefineDirectiveStatementStorageClass ) * sizeOfActualPool) ;
22793 0 : delete [] storageArray;
22794 0 : SgDefineDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22795 : }
22796 :
22797 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDeleteExp );
22798 3 : storageClassIndex = 0 ;
22799 3 : if ( 0 < sizeOfActualPool )
22800 : {
22801 16 : SgDeleteExpStorageClass* storageArray = new SgDeleteExpStorageClass[sizeOfActualPool] ;
22802 1 : storageClassIndex = SgDeleteExp::initializeStorageClassArray (storageArray); ;
22803 1 : assert ( storageClassIndex == sizeOfActualPool );
22804 1 : out.write ( (char*) (storageArray) , sizeof ( SgDeleteExpStorageClass ) * sizeOfActualPool) ;
22805 1 : delete [] storageArray;
22806 1 : SgDeleteExpStorageClass :: writeEasyStorageDataToFile(out) ;
22807 : }
22808 :
22809 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDerivedTypeStatement );
22810 3 : storageClassIndex = 0 ;
22811 3 : if ( 0 < sizeOfActualPool )
22812 : {
22813 0 : SgDerivedTypeStatementStorageClass* storageArray = new SgDerivedTypeStatementStorageClass[sizeOfActualPool] ;
22814 0 : storageClassIndex = SgDerivedTypeStatement::initializeStorageClassArray (storageArray); ;
22815 0 : assert ( storageClassIndex == sizeOfActualPool );
22816 0 : out.write ( (char*) (storageArray) , sizeof ( SgDerivedTypeStatementStorageClass ) * sizeOfActualPool) ;
22817 0 : delete [] storageArray;
22818 0 : SgDerivedTypeStatementStorageClass :: writeEasyStorageDataToFile(out) ;
22819 : }
22820 :
22821 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDesignatedInitializer );
22822 3 : storageClassIndex = 0 ;
22823 3 : if ( 0 < sizeOfActualPool )
22824 : {
22825 0 : SgDesignatedInitializerStorageClass* storageArray = new SgDesignatedInitializerStorageClass[sizeOfActualPool] ;
22826 0 : storageClassIndex = SgDesignatedInitializer::initializeStorageClassArray (storageArray); ;
22827 0 : assert ( storageClassIndex == sizeOfActualPool );
22828 0 : out.write ( (char*) (storageArray) , sizeof ( SgDesignatedInitializerStorageClass ) * sizeOfActualPool) ;
22829 0 : delete [] storageArray;
22830 0 : SgDesignatedInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
22831 : }
22832 :
22833 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDictionaryComprehension );
22834 3 : storageClassIndex = 0 ;
22835 3 : if ( 0 < sizeOfActualPool )
22836 : {
22837 0 : SgDictionaryComprehensionStorageClass* storageArray = new SgDictionaryComprehensionStorageClass[sizeOfActualPool] ;
22838 0 : storageClassIndex = SgDictionaryComprehension::initializeStorageClassArray (storageArray); ;
22839 0 : assert ( storageClassIndex == sizeOfActualPool );
22840 0 : out.write ( (char*) (storageArray) , sizeof ( SgDictionaryComprehensionStorageClass ) * sizeOfActualPool) ;
22841 0 : delete [] storageArray;
22842 0 : SgDictionaryComprehensionStorageClass :: writeEasyStorageDataToFile(out) ;
22843 : }
22844 :
22845 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDictionaryExp );
22846 3 : storageClassIndex = 0 ;
22847 3 : if ( 0 < sizeOfActualPool )
22848 : {
22849 0 : SgDictionaryExpStorageClass* storageArray = new SgDictionaryExpStorageClass[sizeOfActualPool] ;
22850 0 : storageClassIndex = SgDictionaryExp::initializeStorageClassArray (storageArray); ;
22851 0 : assert ( storageClassIndex == sizeOfActualPool );
22852 0 : out.write ( (char*) (storageArray) , sizeof ( SgDictionaryExpStorageClass ) * sizeOfActualPool) ;
22853 0 : delete [] storageArray;
22854 0 : SgDictionaryExpStorageClass :: writeEasyStorageDataToFile(out) ;
22855 : }
22856 :
22857 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDimensionObject );
22858 3 : storageClassIndex = 0 ;
22859 3 : if ( 0 < sizeOfActualPool )
22860 : {
22861 0 : SgDimensionObjectStorageClass* storageArray = new SgDimensionObjectStorageClass[sizeOfActualPool] ;
22862 0 : storageClassIndex = SgDimensionObject::initializeStorageClassArray (storageArray); ;
22863 0 : assert ( storageClassIndex == sizeOfActualPool );
22864 0 : out.write ( (char*) (storageArray) , sizeof ( SgDimensionObjectStorageClass ) * sizeOfActualPool) ;
22865 0 : delete [] storageArray;
22866 : }
22867 :
22868 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDirectedGraphEdge );
22869 3 : storageClassIndex = 0 ;
22870 3 : if ( 0 < sizeOfActualPool )
22871 : {
22872 0 : SgDirectedGraphEdgeStorageClass* storageArray = new SgDirectedGraphEdgeStorageClass[sizeOfActualPool] ;
22873 0 : storageClassIndex = SgDirectedGraphEdge::initializeStorageClassArray (storageArray); ;
22874 0 : assert ( storageClassIndex == sizeOfActualPool );
22875 0 : out.write ( (char*) (storageArray) , sizeof ( SgDirectedGraphEdgeStorageClass ) * sizeOfActualPool) ;
22876 0 : delete [] storageArray;
22877 0 : SgDirectedGraphEdgeStorageClass :: writeEasyStorageDataToFile(out) ;
22878 : }
22879 :
22880 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDirectory );
22881 3 : storageClassIndex = 0 ;
22882 3 : if ( 0 < sizeOfActualPool )
22883 : {
22884 0 : SgDirectoryStorageClass* storageArray = new SgDirectoryStorageClass[sizeOfActualPool] ;
22885 0 : storageClassIndex = SgDirectory::initializeStorageClassArray (storageArray); ;
22886 0 : assert ( storageClassIndex == sizeOfActualPool );
22887 0 : out.write ( (char*) (storageArray) , sizeof ( SgDirectoryStorageClass ) * sizeOfActualPool) ;
22888 0 : delete [] storageArray;
22889 0 : SgDirectoryStorageClass :: writeEasyStorageDataToFile(out) ;
22890 : }
22891 :
22892 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDirectoryList );
22893 3 : storageClassIndex = 0 ;
22894 3 : if ( 0 < sizeOfActualPool )
22895 : {
22896 6 : SgDirectoryListStorageClass* storageArray = new SgDirectoryListStorageClass[sizeOfActualPool] ;
22897 3 : storageClassIndex = SgDirectoryList::initializeStorageClassArray (storageArray); ;
22898 3 : assert ( storageClassIndex == sizeOfActualPool );
22899 3 : out.write ( (char*) (storageArray) , sizeof ( SgDirectoryListStorageClass ) * sizeOfActualPool) ;
22900 3 : delete [] storageArray;
22901 3 : SgDirectoryListStorageClass :: writeEasyStorageDataToFile(out) ;
22902 : }
22903 :
22904 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDivAssignOp );
22905 3 : storageClassIndex = 0 ;
22906 3 : if ( 0 < sizeOfActualPool )
22907 : {
22908 2 : SgDivAssignOpStorageClass* storageArray = new SgDivAssignOpStorageClass[sizeOfActualPool] ;
22909 1 : storageClassIndex = SgDivAssignOp::initializeStorageClassArray (storageArray); ;
22910 1 : assert ( storageClassIndex == sizeOfActualPool );
22911 1 : out.write ( (char*) (storageArray) , sizeof ( SgDivAssignOpStorageClass ) * sizeOfActualPool) ;
22912 1 : delete [] storageArray;
22913 1 : SgDivAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
22914 : }
22915 :
22916 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDivideOp );
22917 3 : storageClassIndex = 0 ;
22918 3 : if ( 0 < sizeOfActualPool )
22919 : {
22920 38 : SgDivideOpStorageClass* storageArray = new SgDivideOpStorageClass[sizeOfActualPool] ;
22921 1 : storageClassIndex = SgDivideOp::initializeStorageClassArray (storageArray); ;
22922 1 : assert ( storageClassIndex == sizeOfActualPool );
22923 1 : out.write ( (char*) (storageArray) , sizeof ( SgDivideOpStorageClass ) * sizeOfActualPool) ;
22924 1 : delete [] storageArray;
22925 1 : SgDivideOpStorageClass :: writeEasyStorageDataToFile(out) ;
22926 : }
22927 :
22928 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDoWhileStmt );
22929 3 : storageClassIndex = 0 ;
22930 3 : if ( 0 < sizeOfActualPool )
22931 : {
22932 8 : SgDoWhileStmtStorageClass* storageArray = new SgDoWhileStmtStorageClass[sizeOfActualPool] ;
22933 1 : storageClassIndex = SgDoWhileStmt::initializeStorageClassArray (storageArray); ;
22934 1 : assert ( storageClassIndex == sizeOfActualPool );
22935 1 : out.write ( (char*) (storageArray) , sizeof ( SgDoWhileStmtStorageClass ) * sizeOfActualPool) ;
22936 1 : delete [] storageArray;
22937 1 : SgDoWhileStmtStorageClass :: writeEasyStorageDataToFile(out) ;
22938 : }
22939 :
22940 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDotExp );
22941 3 : storageClassIndex = 0 ;
22942 3 : if ( 0 < sizeOfActualPool )
22943 : {
22944 817 : SgDotExpStorageClass* storageArray = new SgDotExpStorageClass[sizeOfActualPool] ;
22945 1 : storageClassIndex = SgDotExp::initializeStorageClassArray (storageArray); ;
22946 1 : assert ( storageClassIndex == sizeOfActualPool );
22947 1 : out.write ( (char*) (storageArray) , sizeof ( SgDotExpStorageClass ) * sizeOfActualPool) ;
22948 1 : delete [] storageArray;
22949 1 : SgDotExpStorageClass :: writeEasyStorageDataToFile(out) ;
22950 : }
22951 :
22952 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDotStarOp );
22953 3 : storageClassIndex = 0 ;
22954 3 : if ( 0 < sizeOfActualPool )
22955 : {
22956 13 : SgDotStarOpStorageClass* storageArray = new SgDotStarOpStorageClass[sizeOfActualPool] ;
22957 1 : storageClassIndex = SgDotStarOp::initializeStorageClassArray (storageArray); ;
22958 1 : assert ( storageClassIndex == sizeOfActualPool );
22959 1 : out.write ( (char*) (storageArray) , sizeof ( SgDotStarOpStorageClass ) * sizeOfActualPool) ;
22960 1 : delete [] storageArray;
22961 1 : SgDotStarOpStorageClass :: writeEasyStorageDataToFile(out) ;
22962 : }
22963 :
22964 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgDoubleVal );
22965 3 : storageClassIndex = 0 ;
22966 3 : if ( 0 < sizeOfActualPool )
22967 : {
22968 2 : SgDoubleValStorageClass* storageArray = new SgDoubleValStorageClass[sizeOfActualPool] ;
22969 1 : storageClassIndex = SgDoubleVal::initializeStorageClassArray (storageArray); ;
22970 1 : assert ( storageClassIndex == sizeOfActualPool );
22971 1 : out.write ( (char*) (storageArray) , sizeof ( SgDoubleValStorageClass ) * sizeOfActualPool) ;
22972 1 : delete [] storageArray;
22973 1 : SgDoubleValStorageClass :: writeEasyStorageDataToFile(out) ;
22974 : }
22975 :
22976 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElaboratedTypeModifier );
22977 3 : storageClassIndex = 0 ;
22978 3 : if ( 0 < sizeOfActualPool )
22979 : {
22980 0 : SgElaboratedTypeModifierStorageClass* storageArray = new SgElaboratedTypeModifierStorageClass[sizeOfActualPool] ;
22981 0 : storageClassIndex = SgElaboratedTypeModifier::initializeStorageClassArray (storageArray); ;
22982 0 : assert ( storageClassIndex == sizeOfActualPool );
22983 0 : out.write ( (char*) (storageArray) , sizeof ( SgElaboratedTypeModifierStorageClass ) * sizeOfActualPool) ;
22984 0 : delete [] storageArray;
22985 : }
22986 :
22987 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseOp );
22988 3 : storageClassIndex = 0 ;
22989 3 : if ( 0 < sizeOfActualPool )
22990 : {
22991 0 : SgElementwiseOpStorageClass* storageArray = new SgElementwiseOpStorageClass[sizeOfActualPool] ;
22992 0 : storageClassIndex = SgElementwiseOp::initializeStorageClassArray (storageArray); ;
22993 0 : assert ( storageClassIndex == sizeOfActualPool );
22994 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseOpStorageClass ) * sizeOfActualPool) ;
22995 0 : delete [] storageArray;
22996 0 : SgElementwiseOpStorageClass :: writeEasyStorageDataToFile(out) ;
22997 : }
22998 :
22999 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseAddOp );
23000 3 : storageClassIndex = 0 ;
23001 3 : if ( 0 < sizeOfActualPool )
23002 : {
23003 0 : SgElementwiseAddOpStorageClass* storageArray = new SgElementwiseAddOpStorageClass[sizeOfActualPool] ;
23004 0 : storageClassIndex = SgElementwiseAddOp::initializeStorageClassArray (storageArray); ;
23005 0 : assert ( storageClassIndex == sizeOfActualPool );
23006 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseAddOpStorageClass ) * sizeOfActualPool) ;
23007 0 : delete [] storageArray;
23008 0 : SgElementwiseAddOpStorageClass :: writeEasyStorageDataToFile(out) ;
23009 : }
23010 :
23011 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseDivideOp );
23012 3 : storageClassIndex = 0 ;
23013 3 : if ( 0 < sizeOfActualPool )
23014 : {
23015 0 : SgElementwiseDivideOpStorageClass* storageArray = new SgElementwiseDivideOpStorageClass[sizeOfActualPool] ;
23016 0 : storageClassIndex = SgElementwiseDivideOp::initializeStorageClassArray (storageArray); ;
23017 0 : assert ( storageClassIndex == sizeOfActualPool );
23018 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseDivideOpStorageClass ) * sizeOfActualPool) ;
23019 0 : delete [] storageArray;
23020 0 : SgElementwiseDivideOpStorageClass :: writeEasyStorageDataToFile(out) ;
23021 : }
23022 :
23023 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseLeftDivideOp );
23024 3 : storageClassIndex = 0 ;
23025 3 : if ( 0 < sizeOfActualPool )
23026 : {
23027 0 : SgElementwiseLeftDivideOpStorageClass* storageArray = new SgElementwiseLeftDivideOpStorageClass[sizeOfActualPool] ;
23028 0 : storageClassIndex = SgElementwiseLeftDivideOp::initializeStorageClassArray (storageArray); ;
23029 0 : assert ( storageClassIndex == sizeOfActualPool );
23030 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseLeftDivideOpStorageClass ) * sizeOfActualPool) ;
23031 0 : delete [] storageArray;
23032 0 : SgElementwiseLeftDivideOpStorageClass :: writeEasyStorageDataToFile(out) ;
23033 : }
23034 :
23035 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseMultiplyOp );
23036 3 : storageClassIndex = 0 ;
23037 3 : if ( 0 < sizeOfActualPool )
23038 : {
23039 0 : SgElementwiseMultiplyOpStorageClass* storageArray = new SgElementwiseMultiplyOpStorageClass[sizeOfActualPool] ;
23040 0 : storageClassIndex = SgElementwiseMultiplyOp::initializeStorageClassArray (storageArray); ;
23041 0 : assert ( storageClassIndex == sizeOfActualPool );
23042 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseMultiplyOpStorageClass ) * sizeOfActualPool) ;
23043 0 : delete [] storageArray;
23044 0 : SgElementwiseMultiplyOpStorageClass :: writeEasyStorageDataToFile(out) ;
23045 : }
23046 :
23047 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwisePowerOp );
23048 3 : storageClassIndex = 0 ;
23049 3 : if ( 0 < sizeOfActualPool )
23050 : {
23051 0 : SgElementwisePowerOpStorageClass* storageArray = new SgElementwisePowerOpStorageClass[sizeOfActualPool] ;
23052 0 : storageClassIndex = SgElementwisePowerOp::initializeStorageClassArray (storageArray); ;
23053 0 : assert ( storageClassIndex == sizeOfActualPool );
23054 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwisePowerOpStorageClass ) * sizeOfActualPool) ;
23055 0 : delete [] storageArray;
23056 0 : SgElementwisePowerOpStorageClass :: writeEasyStorageDataToFile(out) ;
23057 : }
23058 :
23059 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElementwiseSubtractOp );
23060 3 : storageClassIndex = 0 ;
23061 3 : if ( 0 < sizeOfActualPool )
23062 : {
23063 0 : SgElementwiseSubtractOpStorageClass* storageArray = new SgElementwiseSubtractOpStorageClass[sizeOfActualPool] ;
23064 0 : storageClassIndex = SgElementwiseSubtractOp::initializeStorageClassArray (storageArray); ;
23065 0 : assert ( storageClassIndex == sizeOfActualPool );
23066 0 : out.write ( (char*) (storageArray) , sizeof ( SgElementwiseSubtractOpStorageClass ) * sizeOfActualPool) ;
23067 0 : delete [] storageArray;
23068 0 : SgElementwiseSubtractOpStorageClass :: writeEasyStorageDataToFile(out) ;
23069 : }
23070 :
23071 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElseDirectiveStatement );
23072 3 : storageClassIndex = 0 ;
23073 3 : if ( 0 < sizeOfActualPool )
23074 : {
23075 0 : SgElseDirectiveStatementStorageClass* storageArray = new SgElseDirectiveStatementStorageClass[sizeOfActualPool] ;
23076 0 : storageClassIndex = SgElseDirectiveStatement::initializeStorageClassArray (storageArray); ;
23077 0 : assert ( storageClassIndex == sizeOfActualPool );
23078 0 : out.write ( (char*) (storageArray) , sizeof ( SgElseDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23079 0 : delete [] storageArray;
23080 0 : SgElseDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23081 : }
23082 :
23083 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElseWhereStatement );
23084 3 : storageClassIndex = 0 ;
23085 3 : if ( 0 < sizeOfActualPool )
23086 : {
23087 0 : SgElseWhereStatementStorageClass* storageArray = new SgElseWhereStatementStorageClass[sizeOfActualPool] ;
23088 0 : storageClassIndex = SgElseWhereStatement::initializeStorageClassArray (storageArray); ;
23089 0 : assert ( storageClassIndex == sizeOfActualPool );
23090 0 : out.write ( (char*) (storageArray) , sizeof ( SgElseWhereStatementStorageClass ) * sizeOfActualPool) ;
23091 0 : delete [] storageArray;
23092 0 : SgElseWhereStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23093 : }
23094 :
23095 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgElseifDirectiveStatement );
23096 3 : storageClassIndex = 0 ;
23097 3 : if ( 0 < sizeOfActualPool )
23098 : {
23099 0 : SgElseifDirectiveStatementStorageClass* storageArray = new SgElseifDirectiveStatementStorageClass[sizeOfActualPool] ;
23100 0 : storageClassIndex = SgElseifDirectiveStatement::initializeStorageClassArray (storageArray); ;
23101 0 : assert ( storageClassIndex == sizeOfActualPool );
23102 0 : out.write ( (char*) (storageArray) , sizeof ( SgElseifDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23103 0 : delete [] storageArray;
23104 0 : SgElseifDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23105 : }
23106 :
23107 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEmptyDeclaration );
23108 3 : storageClassIndex = 0 ;
23109 3 : if ( 0 < sizeOfActualPool )
23110 : {
23111 0 : SgEmptyDeclarationStorageClass* storageArray = new SgEmptyDeclarationStorageClass[sizeOfActualPool] ;
23112 0 : storageClassIndex = SgEmptyDeclaration::initializeStorageClassArray (storageArray); ;
23113 0 : assert ( storageClassIndex == sizeOfActualPool );
23114 0 : out.write ( (char*) (storageArray) , sizeof ( SgEmptyDeclarationStorageClass ) * sizeOfActualPool) ;
23115 0 : delete [] storageArray;
23116 0 : SgEmptyDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
23117 : }
23118 :
23119 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEmptyDirectiveStatement );
23120 3 : storageClassIndex = 0 ;
23121 3 : if ( 0 < sizeOfActualPool )
23122 : {
23123 0 : SgEmptyDirectiveStatementStorageClass* storageArray = new SgEmptyDirectiveStatementStorageClass[sizeOfActualPool] ;
23124 0 : storageClassIndex = SgEmptyDirectiveStatement::initializeStorageClassArray (storageArray); ;
23125 0 : assert ( storageClassIndex == sizeOfActualPool );
23126 0 : out.write ( (char*) (storageArray) , sizeof ( SgEmptyDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23127 0 : delete [] storageArray;
23128 0 : SgEmptyDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23129 : }
23130 :
23131 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEndfileStatement );
23132 3 : storageClassIndex = 0 ;
23133 3 : if ( 0 < sizeOfActualPool )
23134 : {
23135 0 : SgEndfileStatementStorageClass* storageArray = new SgEndfileStatementStorageClass[sizeOfActualPool] ;
23136 0 : storageClassIndex = SgEndfileStatement::initializeStorageClassArray (storageArray); ;
23137 0 : assert ( storageClassIndex == sizeOfActualPool );
23138 0 : out.write ( (char*) (storageArray) , sizeof ( SgEndfileStatementStorageClass ) * sizeOfActualPool) ;
23139 0 : delete [] storageArray;
23140 0 : SgEndfileStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23141 : }
23142 :
23143 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEndifDirectiveStatement );
23144 3 : storageClassIndex = 0 ;
23145 3 : if ( 0 < sizeOfActualPool )
23146 : {
23147 0 : SgEndifDirectiveStatementStorageClass* storageArray = new SgEndifDirectiveStatementStorageClass[sizeOfActualPool] ;
23148 0 : storageClassIndex = SgEndifDirectiveStatement::initializeStorageClassArray (storageArray); ;
23149 0 : assert ( storageClassIndex == sizeOfActualPool );
23150 0 : out.write ( (char*) (storageArray) , sizeof ( SgEndifDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23151 0 : delete [] storageArray;
23152 0 : SgEndifDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23153 : }
23154 :
23155 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEntryStatement );
23156 3 : storageClassIndex = 0 ;
23157 3 : if ( 0 < sizeOfActualPool )
23158 : {
23159 0 : SgEntryStatementStorageClass* storageArray = new SgEntryStatementStorageClass[sizeOfActualPool] ;
23160 0 : storageClassIndex = SgEntryStatement::initializeStorageClassArray (storageArray); ;
23161 0 : assert ( storageClassIndex == sizeOfActualPool );
23162 0 : out.write ( (char*) (storageArray) , sizeof ( SgEntryStatementStorageClass ) * sizeOfActualPool) ;
23163 0 : delete [] storageArray;
23164 0 : SgEntryStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23165 : }
23166 :
23167 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEnumDeclaration );
23168 3 : storageClassIndex = 0 ;
23169 3 : if ( 0 < sizeOfActualPool )
23170 : {
23171 177 : SgEnumDeclarationStorageClass* storageArray = new SgEnumDeclarationStorageClass[sizeOfActualPool] ;
23172 1 : storageClassIndex = SgEnumDeclaration::initializeStorageClassArray (storageArray); ;
23173 1 : assert ( storageClassIndex == sizeOfActualPool );
23174 1 : out.write ( (char*) (storageArray) , sizeof ( SgEnumDeclarationStorageClass ) * sizeOfActualPool) ;
23175 1 : delete [] storageArray;
23176 1 : SgEnumDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
23177 : }
23178 :
23179 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEnumFieldSymbol );
23180 3 : storageClassIndex = 0 ;
23181 3 : if ( 0 < sizeOfActualPool )
23182 : {
23183 280 : SgEnumFieldSymbolStorageClass* storageArray = new SgEnumFieldSymbolStorageClass[sizeOfActualPool] ;
23184 1 : storageClassIndex = SgEnumFieldSymbol::initializeStorageClassArray (storageArray); ;
23185 1 : assert ( storageClassIndex == sizeOfActualPool );
23186 1 : out.write ( (char*) (storageArray) , sizeof ( SgEnumFieldSymbolStorageClass ) * sizeOfActualPool) ;
23187 1 : delete [] storageArray;
23188 1 : SgEnumFieldSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
23189 : }
23190 :
23191 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEnumSymbol );
23192 3 : storageClassIndex = 0 ;
23193 3 : if ( 0 < sizeOfActualPool )
23194 : {
23195 89 : SgEnumSymbolStorageClass* storageArray = new SgEnumSymbolStorageClass[sizeOfActualPool] ;
23196 1 : storageClassIndex = SgEnumSymbol::initializeStorageClassArray (storageArray); ;
23197 1 : assert ( storageClassIndex == sizeOfActualPool );
23198 1 : out.write ( (char*) (storageArray) , sizeof ( SgEnumSymbolStorageClass ) * sizeOfActualPool) ;
23199 1 : delete [] storageArray;
23200 1 : SgEnumSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
23201 : }
23202 :
23203 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEnumType );
23204 3 : storageClassIndex = 0 ;
23205 3 : if ( 0 < sizeOfActualPool )
23206 : {
23207 88 : SgEnumTypeStorageClass* storageArray = new SgEnumTypeStorageClass[sizeOfActualPool] ;
23208 1 : storageClassIndex = SgEnumType::initializeStorageClassArray (storageArray); ;
23209 1 : assert ( storageClassIndex == sizeOfActualPool );
23210 1 : out.write ( (char*) (storageArray) , sizeof ( SgEnumTypeStorageClass ) * sizeOfActualPool) ;
23211 1 : delete [] storageArray;
23212 1 : SgEnumTypeStorageClass :: writeEasyStorageDataToFile(out) ;
23213 : }
23214 :
23215 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEnumVal );
23216 3 : storageClassIndex = 0 ;
23217 3 : if ( 0 < sizeOfActualPool )
23218 : {
23219 551 : SgEnumValStorageClass* storageArray = new SgEnumValStorageClass[sizeOfActualPool] ;
23220 1 : storageClassIndex = SgEnumVal::initializeStorageClassArray (storageArray); ;
23221 1 : assert ( storageClassIndex == sizeOfActualPool );
23222 1 : out.write ( (char*) (storageArray) , sizeof ( SgEnumValStorageClass ) * sizeOfActualPool) ;
23223 1 : delete [] storageArray;
23224 1 : SgEnumValStorageClass :: writeEasyStorageDataToFile(out) ;
23225 : }
23226 :
23227 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEqualityOp );
23228 3 : storageClassIndex = 0 ;
23229 3 : if ( 0 < sizeOfActualPool )
23230 : {
23231 251 : SgEqualityOpStorageClass* storageArray = new SgEqualityOpStorageClass[sizeOfActualPool] ;
23232 1 : storageClassIndex = SgEqualityOp::initializeStorageClassArray (storageArray); ;
23233 1 : assert ( storageClassIndex == sizeOfActualPool );
23234 1 : out.write ( (char*) (storageArray) , sizeof ( SgEqualityOpStorageClass ) * sizeOfActualPool) ;
23235 1 : delete [] storageArray;
23236 1 : SgEqualityOpStorageClass :: writeEasyStorageDataToFile(out) ;
23237 : }
23238 :
23239 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgEquivalenceStatement );
23240 3 : storageClassIndex = 0 ;
23241 3 : if ( 0 < sizeOfActualPool )
23242 : {
23243 0 : SgEquivalenceStatementStorageClass* storageArray = new SgEquivalenceStatementStorageClass[sizeOfActualPool] ;
23244 0 : storageClassIndex = SgEquivalenceStatement::initializeStorageClassArray (storageArray); ;
23245 0 : assert ( storageClassIndex == sizeOfActualPool );
23246 0 : out.write ( (char*) (storageArray) , sizeof ( SgEquivalenceStatementStorageClass ) * sizeOfActualPool) ;
23247 0 : delete [] storageArray;
23248 0 : SgEquivalenceStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23249 : }
23250 :
23251 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgErrorDirectiveStatement );
23252 3 : storageClassIndex = 0 ;
23253 3 : if ( 0 < sizeOfActualPool )
23254 : {
23255 0 : SgErrorDirectiveStatementStorageClass* storageArray = new SgErrorDirectiveStatementStorageClass[sizeOfActualPool] ;
23256 0 : storageClassIndex = SgErrorDirectiveStatement::initializeStorageClassArray (storageArray); ;
23257 0 : assert ( storageClassIndex == sizeOfActualPool );
23258 0 : out.write ( (char*) (storageArray) , sizeof ( SgErrorDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23259 0 : delete [] storageArray;
23260 0 : SgErrorDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23261 : }
23262 :
23263 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExecStatement );
23264 3 : storageClassIndex = 0 ;
23265 3 : if ( 0 < sizeOfActualPool )
23266 : {
23267 0 : SgExecStatementStorageClass* storageArray = new SgExecStatementStorageClass[sizeOfActualPool] ;
23268 0 : storageClassIndex = SgExecStatement::initializeStorageClassArray (storageArray); ;
23269 0 : assert ( storageClassIndex == sizeOfActualPool );
23270 0 : out.write ( (char*) (storageArray) , sizeof ( SgExecStatementStorageClass ) * sizeOfActualPool) ;
23271 0 : delete [] storageArray;
23272 0 : SgExecStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23273 : }
23274 :
23275 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExponentiationOp );
23276 3 : storageClassIndex = 0 ;
23277 3 : if ( 0 < sizeOfActualPool )
23278 : {
23279 0 : SgExponentiationOpStorageClass* storageArray = new SgExponentiationOpStorageClass[sizeOfActualPool] ;
23280 0 : storageClassIndex = SgExponentiationOp::initializeStorageClassArray (storageArray); ;
23281 0 : assert ( storageClassIndex == sizeOfActualPool );
23282 0 : out.write ( (char*) (storageArray) , sizeof ( SgExponentiationOpStorageClass ) * sizeOfActualPool) ;
23283 0 : delete [] storageArray;
23284 0 : SgExponentiationOpStorageClass :: writeEasyStorageDataToFile(out) ;
23285 : }
23286 :
23287 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExponentiationAssignOp );
23288 3 : storageClassIndex = 0 ;
23289 3 : if ( 0 < sizeOfActualPool )
23290 : {
23291 0 : SgExponentiationAssignOpStorageClass* storageArray = new SgExponentiationAssignOpStorageClass[sizeOfActualPool] ;
23292 0 : storageClassIndex = SgExponentiationAssignOp::initializeStorageClassArray (storageArray); ;
23293 0 : assert ( storageClassIndex == sizeOfActualPool );
23294 0 : out.write ( (char*) (storageArray) , sizeof ( SgExponentiationAssignOpStorageClass ) * sizeOfActualPool) ;
23295 0 : delete [] storageArray;
23296 0 : SgExponentiationAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
23297 : }
23298 :
23299 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExprListExp );
23300 3 : storageClassIndex = 0 ;
23301 3 : if ( 0 < sizeOfActualPool )
23302 : {
23303 3695 : SgExprListExpStorageClass* storageArray = new SgExprListExpStorageClass[sizeOfActualPool] ;
23304 3 : storageClassIndex = SgExprListExp::initializeStorageClassArray (storageArray); ;
23305 3 : assert ( storageClassIndex == sizeOfActualPool );
23306 3 : out.write ( (char*) (storageArray) , sizeof ( SgExprListExpStorageClass ) * sizeOfActualPool) ;
23307 3 : delete [] storageArray;
23308 3 : SgExprListExpStorageClass :: writeEasyStorageDataToFile(out) ;
23309 : }
23310 :
23311 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExprStatement );
23312 3 : storageClassIndex = 0 ;
23313 3 : if ( 0 < sizeOfActualPool )
23314 : {
23315 2210 : SgExprStatementStorageClass* storageArray = new SgExprStatementStorageClass[sizeOfActualPool] ;
23316 2 : storageClassIndex = SgExprStatement::initializeStorageClassArray (storageArray); ;
23317 2 : assert ( storageClassIndex == sizeOfActualPool );
23318 2 : out.write ( (char*) (storageArray) , sizeof ( SgExprStatementStorageClass ) * sizeOfActualPool) ;
23319 2 : delete [] storageArray;
23320 2 : SgExprStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23321 : }
23322 :
23323 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExpression );
23324 3 : storageClassIndex = 0 ;
23325 3 : if ( 0 < sizeOfActualPool )
23326 : {
23327 0 : SgExpressionStorageClass* storageArray = new SgExpressionStorageClass[sizeOfActualPool] ;
23328 0 : storageClassIndex = SgExpression::initializeStorageClassArray (storageArray); ;
23329 0 : assert ( storageClassIndex == sizeOfActualPool );
23330 0 : out.write ( (char*) (storageArray) , sizeof ( SgExpressionStorageClass ) * sizeOfActualPool) ;
23331 0 : delete [] storageArray;
23332 0 : SgExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
23333 : }
23334 :
23335 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgExpressionRoot );
23336 3 : storageClassIndex = 0 ;
23337 3 : if ( 0 < sizeOfActualPool )
23338 : {
23339 0 : SgExpressionRootStorageClass* storageArray = new SgExpressionRootStorageClass[sizeOfActualPool] ;
23340 0 : storageClassIndex = SgExpressionRoot::initializeStorageClassArray (storageArray); ;
23341 0 : assert ( storageClassIndex == sizeOfActualPool );
23342 0 : out.write ( (char*) (storageArray) , sizeof ( SgExpressionRootStorageClass ) * sizeOfActualPool) ;
23343 0 : delete [] storageArray;
23344 0 : SgExpressionRootStorageClass :: writeEasyStorageDataToFile(out) ;
23345 : }
23346 :
23347 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFile );
23348 3 : storageClassIndex = 0 ;
23349 3 : if ( 0 < sizeOfActualPool )
23350 : {
23351 0 : SgFileStorageClass* storageArray = new SgFileStorageClass[sizeOfActualPool] ;
23352 0 : storageClassIndex = SgFile::initializeStorageClassArray (storageArray); ;
23353 0 : assert ( storageClassIndex == sizeOfActualPool );
23354 0 : out.write ( (char*) (storageArray) , sizeof ( SgFileStorageClass ) * sizeOfActualPool) ;
23355 0 : delete [] storageArray;
23356 0 : SgFileStorageClass :: writeEasyStorageDataToFile(out) ;
23357 : }
23358 :
23359 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFileList );
23360 3 : storageClassIndex = 0 ;
23361 3 : if ( 0 < sizeOfActualPool )
23362 : {
23363 6 : SgFileListStorageClass* storageArray = new SgFileListStorageClass[sizeOfActualPool] ;
23364 3 : storageClassIndex = SgFileList::initializeStorageClassArray (storageArray); ;
23365 3 : assert ( storageClassIndex == sizeOfActualPool );
23366 3 : out.write ( (char*) (storageArray) , sizeof ( SgFileListStorageClass ) * sizeOfActualPool) ;
23367 3 : delete [] storageArray;
23368 3 : SgFileListStorageClass :: writeEasyStorageDataToFile(out) ;
23369 : }
23370 :
23371 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFloatVal );
23372 3 : storageClassIndex = 0 ;
23373 3 : if ( 0 < sizeOfActualPool )
23374 : {
23375 2 : SgFloatValStorageClass* storageArray = new SgFloatValStorageClass[sizeOfActualPool] ;
23376 1 : storageClassIndex = SgFloatVal::initializeStorageClassArray (storageArray); ;
23377 1 : assert ( storageClassIndex == sizeOfActualPool );
23378 1 : out.write ( (char*) (storageArray) , sizeof ( SgFloatValStorageClass ) * sizeOfActualPool) ;
23379 1 : delete [] storageArray;
23380 1 : SgFloatValStorageClass :: writeEasyStorageDataToFile(out) ;
23381 : }
23382 :
23383 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFloat128Val );
23384 3 : storageClassIndex = 0 ;
23385 3 : if ( 0 < sizeOfActualPool )
23386 : {
23387 0 : SgFloat128ValStorageClass* storageArray = new SgFloat128ValStorageClass[sizeOfActualPool] ;
23388 0 : storageClassIndex = SgFloat128Val::initializeStorageClassArray (storageArray); ;
23389 0 : assert ( storageClassIndex == sizeOfActualPool );
23390 0 : out.write ( (char*) (storageArray) , sizeof ( SgFloat128ValStorageClass ) * sizeOfActualPool) ;
23391 0 : delete [] storageArray;
23392 0 : SgFloat128ValStorageClass :: writeEasyStorageDataToFile(out) ;
23393 : }
23394 :
23395 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFloat80Val );
23396 3 : storageClassIndex = 0 ;
23397 3 : if ( 0 < sizeOfActualPool )
23398 : {
23399 0 : SgFloat80ValStorageClass* storageArray = new SgFloat80ValStorageClass[sizeOfActualPool] ;
23400 0 : storageClassIndex = SgFloat80Val::initializeStorageClassArray (storageArray); ;
23401 0 : assert ( storageClassIndex == sizeOfActualPool );
23402 0 : out.write ( (char*) (storageArray) , sizeof ( SgFloat80ValStorageClass ) * sizeOfActualPool) ;
23403 0 : delete [] storageArray;
23404 0 : SgFloat80ValStorageClass :: writeEasyStorageDataToFile(out) ;
23405 : }
23406 :
23407 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFoldExpression );
23408 3 : storageClassIndex = 0 ;
23409 3 : if ( 0 < sizeOfActualPool )
23410 : {
23411 0 : SgFoldExpressionStorageClass* storageArray = new SgFoldExpressionStorageClass[sizeOfActualPool] ;
23412 0 : storageClassIndex = SgFoldExpression::initializeStorageClassArray (storageArray); ;
23413 0 : assert ( storageClassIndex == sizeOfActualPool );
23414 0 : out.write ( (char*) (storageArray) , sizeof ( SgFoldExpressionStorageClass ) * sizeOfActualPool) ;
23415 0 : delete [] storageArray;
23416 0 : SgFoldExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
23417 : }
23418 :
23419 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFlushStatement );
23420 3 : storageClassIndex = 0 ;
23421 3 : if ( 0 < sizeOfActualPool )
23422 : {
23423 0 : SgFlushStatementStorageClass* storageArray = new SgFlushStatementStorageClass[sizeOfActualPool] ;
23424 0 : storageClassIndex = SgFlushStatement::initializeStorageClassArray (storageArray); ;
23425 0 : assert ( storageClassIndex == sizeOfActualPool );
23426 0 : out.write ( (char*) (storageArray) , sizeof ( SgFlushStatementStorageClass ) * sizeOfActualPool) ;
23427 0 : delete [] storageArray;
23428 0 : SgFlushStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23429 : }
23430 :
23431 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgForAllStatement );
23432 3 : storageClassIndex = 0 ;
23433 3 : if ( 0 < sizeOfActualPool )
23434 : {
23435 0 : SgForAllStatementStorageClass* storageArray = new SgForAllStatementStorageClass[sizeOfActualPool] ;
23436 0 : storageClassIndex = SgForAllStatement::initializeStorageClassArray (storageArray); ;
23437 0 : assert ( storageClassIndex == sizeOfActualPool );
23438 0 : out.write ( (char*) (storageArray) , sizeof ( SgForAllStatementStorageClass ) * sizeOfActualPool) ;
23439 0 : delete [] storageArray;
23440 0 : SgForAllStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23441 : }
23442 :
23443 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgForInitStatement );
23444 3 : storageClassIndex = 0 ;
23445 3 : if ( 0 < sizeOfActualPool )
23446 : {
23447 41 : SgForInitStatementStorageClass* storageArray = new SgForInitStatementStorageClass[sizeOfActualPool] ;
23448 1 : storageClassIndex = SgForInitStatement::initializeStorageClassArray (storageArray); ;
23449 1 : assert ( storageClassIndex == sizeOfActualPool );
23450 1 : out.write ( (char*) (storageArray) , sizeof ( SgForInitStatementStorageClass ) * sizeOfActualPool) ;
23451 1 : delete [] storageArray;
23452 1 : SgForInitStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23453 : }
23454 :
23455 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgForStatement );
23456 3 : storageClassIndex = 0 ;
23457 3 : if ( 0 < sizeOfActualPool )
23458 : {
23459 41 : SgForStatementStorageClass* storageArray = new SgForStatementStorageClass[sizeOfActualPool] ;
23460 1 : storageClassIndex = SgForStatement::initializeStorageClassArray (storageArray); ;
23461 1 : assert ( storageClassIndex == sizeOfActualPool );
23462 1 : out.write ( (char*) (storageArray) , sizeof ( SgForStatementStorageClass ) * sizeOfActualPool) ;
23463 1 : delete [] storageArray;
23464 1 : SgForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23465 : }
23466 :
23467 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFormatItem );
23468 3 : storageClassIndex = 0 ;
23469 3 : if ( 0 < sizeOfActualPool )
23470 : {
23471 0 : SgFormatItemStorageClass* storageArray = new SgFormatItemStorageClass[sizeOfActualPool] ;
23472 0 : storageClassIndex = SgFormatItem::initializeStorageClassArray (storageArray); ;
23473 0 : assert ( storageClassIndex == sizeOfActualPool );
23474 0 : out.write ( (char*) (storageArray) , sizeof ( SgFormatItemStorageClass ) * sizeOfActualPool) ;
23475 0 : delete [] storageArray;
23476 : }
23477 :
23478 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFormatItemList );
23479 3 : storageClassIndex = 0 ;
23480 3 : if ( 0 < sizeOfActualPool )
23481 : {
23482 0 : SgFormatItemListStorageClass* storageArray = new SgFormatItemListStorageClass[sizeOfActualPool] ;
23483 0 : storageClassIndex = SgFormatItemList::initializeStorageClassArray (storageArray); ;
23484 0 : assert ( storageClassIndex == sizeOfActualPool );
23485 0 : out.write ( (char*) (storageArray) , sizeof ( SgFormatItemListStorageClass ) * sizeOfActualPool) ;
23486 0 : delete [] storageArray;
23487 0 : SgFormatItemListStorageClass :: writeEasyStorageDataToFile(out) ;
23488 : }
23489 :
23490 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFormatStatement );
23491 3 : storageClassIndex = 0 ;
23492 3 : if ( 0 < sizeOfActualPool )
23493 : {
23494 0 : SgFormatStatementStorageClass* storageArray = new SgFormatStatementStorageClass[sizeOfActualPool] ;
23495 0 : storageClassIndex = SgFormatStatement::initializeStorageClassArray (storageArray); ;
23496 0 : assert ( storageClassIndex == sizeOfActualPool );
23497 0 : out.write ( (char*) (storageArray) , sizeof ( SgFormatStatementStorageClass ) * sizeOfActualPool) ;
23498 0 : delete [] storageArray;
23499 0 : SgFormatStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23500 : }
23501 :
23502 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFortranDo );
23503 3 : storageClassIndex = 0 ;
23504 3 : if ( 0 < sizeOfActualPool )
23505 : {
23506 0 : SgFortranDoStorageClass* storageArray = new SgFortranDoStorageClass[sizeOfActualPool] ;
23507 0 : storageClassIndex = SgFortranDo::initializeStorageClassArray (storageArray); ;
23508 0 : assert ( storageClassIndex == sizeOfActualPool );
23509 0 : out.write ( (char*) (storageArray) , sizeof ( SgFortranDoStorageClass ) * sizeOfActualPool) ;
23510 0 : delete [] storageArray;
23511 0 : SgFortranDoStorageClass :: writeEasyStorageDataToFile(out) ;
23512 : }
23513 :
23514 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFortranIncludeLine );
23515 3 : storageClassIndex = 0 ;
23516 3 : if ( 0 < sizeOfActualPool )
23517 : {
23518 0 : SgFortranIncludeLineStorageClass* storageArray = new SgFortranIncludeLineStorageClass[sizeOfActualPool] ;
23519 0 : storageClassIndex = SgFortranIncludeLine::initializeStorageClassArray (storageArray); ;
23520 0 : assert ( storageClassIndex == sizeOfActualPool );
23521 0 : out.write ( (char*) (storageArray) , sizeof ( SgFortranIncludeLineStorageClass ) * sizeOfActualPool) ;
23522 0 : delete [] storageArray;
23523 0 : SgFortranIncludeLineStorageClass :: writeEasyStorageDataToFile(out) ;
23524 : }
23525 :
23526 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFortranNonblockedDo );
23527 3 : storageClassIndex = 0 ;
23528 3 : if ( 0 < sizeOfActualPool )
23529 : {
23530 0 : SgFortranNonblockedDoStorageClass* storageArray = new SgFortranNonblockedDoStorageClass[sizeOfActualPool] ;
23531 0 : storageClassIndex = SgFortranNonblockedDo::initializeStorageClassArray (storageArray); ;
23532 0 : assert ( storageClassIndex == sizeOfActualPool );
23533 0 : out.write ( (char*) (storageArray) , sizeof ( SgFortranNonblockedDoStorageClass ) * sizeOfActualPool) ;
23534 0 : delete [] storageArray;
23535 0 : SgFortranNonblockedDoStorageClass :: writeEasyStorageDataToFile(out) ;
23536 : }
23537 :
23538 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFuncDecl_attr );
23539 3 : storageClassIndex = 0 ;
23540 3 : if ( 0 < sizeOfActualPool )
23541 : {
23542 0 : SgFuncDecl_attrStorageClass* storageArray = new SgFuncDecl_attrStorageClass[sizeOfActualPool] ;
23543 0 : storageClassIndex = SgFuncDecl_attr::initializeStorageClassArray (storageArray); ;
23544 0 : assert ( storageClassIndex == sizeOfActualPool );
23545 0 : out.write ( (char*) (storageArray) , sizeof ( SgFuncDecl_attrStorageClass ) * sizeOfActualPool) ;
23546 0 : delete [] storageArray;
23547 0 : SgFuncDecl_attrStorageClass :: writeEasyStorageDataToFile(out) ;
23548 : }
23549 :
23550 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionCallExp );
23551 3 : storageClassIndex = 0 ;
23552 3 : if ( 0 < sizeOfActualPool )
23553 : {
23554 3224 : SgFunctionCallExpStorageClass* storageArray = new SgFunctionCallExpStorageClass[sizeOfActualPool] ;
23555 2 : storageClassIndex = SgFunctionCallExp::initializeStorageClassArray (storageArray); ;
23556 2 : assert ( storageClassIndex == sizeOfActualPool );
23557 2 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionCallExpStorageClass ) * sizeOfActualPool) ;
23558 2 : delete [] storageArray;
23559 2 : SgFunctionCallExpStorageClass :: writeEasyStorageDataToFile(out) ;
23560 : }
23561 :
23562 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionDeclaration );
23563 3 : storageClassIndex = 0 ;
23564 3 : if ( 0 < sizeOfActualPool )
23565 : {
23566 7918 : SgFunctionDeclarationStorageClass* storageArray = new SgFunctionDeclarationStorageClass[sizeOfActualPool] ;
23567 2 : storageClassIndex = SgFunctionDeclaration::initializeStorageClassArray (storageArray); ;
23568 2 : assert ( storageClassIndex == sizeOfActualPool );
23569 2 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
23570 2 : delete [] storageArray;
23571 2 : SgFunctionDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
23572 : }
23573 :
23574 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionDefinition );
23575 3 : storageClassIndex = 0 ;
23576 3 : if ( 0 < sizeOfActualPool )
23577 : {
23578 1586 : SgFunctionDefinitionStorageClass* storageArray = new SgFunctionDefinitionStorageClass[sizeOfActualPool] ;
23579 3 : storageClassIndex = SgFunctionDefinition::initializeStorageClassArray (storageArray); ;
23580 3 : assert ( storageClassIndex == sizeOfActualPool );
23581 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionDefinitionStorageClass ) * sizeOfActualPool) ;
23582 3 : delete [] storageArray;
23583 3 : SgFunctionDefinitionStorageClass :: writeEasyStorageDataToFile(out) ;
23584 : }
23585 :
23586 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionParameterScope );
23587 3 : storageClassIndex = 0 ;
23588 3 : if ( 0 < sizeOfActualPool )
23589 : {
23590 0 : SgFunctionParameterScopeStorageClass* storageArray = new SgFunctionParameterScopeStorageClass[sizeOfActualPool] ;
23591 0 : storageClassIndex = SgFunctionParameterScope::initializeStorageClassArray (storageArray); ;
23592 0 : assert ( storageClassIndex == sizeOfActualPool );
23593 0 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionParameterScopeStorageClass ) * sizeOfActualPool) ;
23594 0 : delete [] storageArray;
23595 0 : SgFunctionParameterScopeStorageClass :: writeEasyStorageDataToFile(out) ;
23596 : }
23597 :
23598 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionModifier );
23599 3 : storageClassIndex = 0 ;
23600 3 : if ( 0 < sizeOfActualPool )
23601 : {
23602 0 : SgFunctionModifierStorageClass* storageArray = new SgFunctionModifierStorageClass[sizeOfActualPool] ;
23603 0 : storageClassIndex = SgFunctionModifier::initializeStorageClassArray (storageArray); ;
23604 0 : assert ( storageClassIndex == sizeOfActualPool );
23605 0 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionModifierStorageClass ) * sizeOfActualPool) ;
23606 0 : delete [] storageArray;
23607 0 : SgFunctionModifierStorageClass :: writeEasyStorageDataToFile(out) ;
23608 : }
23609 :
23610 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionParameterList );
23611 3 : storageClassIndex = 0 ;
23612 3 : if ( 0 < sizeOfActualPool )
23613 : {
23614 22771 : SgFunctionParameterListStorageClass* storageArray = new SgFunctionParameterListStorageClass[sizeOfActualPool] ;
23615 3 : storageClassIndex = SgFunctionParameterList::initializeStorageClassArray (storageArray); ;
23616 3 : assert ( storageClassIndex == sizeOfActualPool );
23617 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionParameterListStorageClass ) * sizeOfActualPool) ;
23618 3 : delete [] storageArray;
23619 3 : SgFunctionParameterListStorageClass :: writeEasyStorageDataToFile(out) ;
23620 : }
23621 :
23622 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionParameterRefExp );
23623 3 : storageClassIndex = 0 ;
23624 3 : if ( 0 < sizeOfActualPool )
23625 : {
23626 68 : SgFunctionParameterRefExpStorageClass* storageArray = new SgFunctionParameterRefExpStorageClass[sizeOfActualPool] ;
23627 1 : storageClassIndex = SgFunctionParameterRefExp::initializeStorageClassArray (storageArray); ;
23628 1 : assert ( storageClassIndex == sizeOfActualPool );
23629 1 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionParameterRefExpStorageClass ) * sizeOfActualPool) ;
23630 1 : delete [] storageArray;
23631 1 : SgFunctionParameterRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
23632 : }
23633 :
23634 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionParameterTypeList );
23635 3 : storageClassIndex = 0 ;
23636 3 : if ( 0 < sizeOfActualPool )
23637 : {
23638 8414 : SgFunctionParameterTypeListStorageClass* storageArray = new SgFunctionParameterTypeListStorageClass[sizeOfActualPool] ;
23639 3 : storageClassIndex = SgFunctionParameterTypeList::initializeStorageClassArray (storageArray); ;
23640 3 : assert ( storageClassIndex == sizeOfActualPool );
23641 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionParameterTypeListStorageClass ) * sizeOfActualPool) ;
23642 3 : delete [] storageArray;
23643 3 : SgFunctionParameterTypeListStorageClass :: writeEasyStorageDataToFile(out) ;
23644 : }
23645 :
23646 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionRefExp );
23647 3 : storageClassIndex = 0 ;
23648 3 : if ( 0 < sizeOfActualPool )
23649 : {
23650 610 : SgFunctionRefExpStorageClass* storageArray = new SgFunctionRefExpStorageClass[sizeOfActualPool] ;
23651 2 : storageClassIndex = SgFunctionRefExp::initializeStorageClassArray (storageArray); ;
23652 2 : assert ( storageClassIndex == sizeOfActualPool );
23653 2 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionRefExpStorageClass ) * sizeOfActualPool) ;
23654 2 : delete [] storageArray;
23655 2 : SgFunctionRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
23656 : }
23657 :
23658 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionSymbol );
23659 3 : storageClassIndex = 0 ;
23660 3 : if ( 0 < sizeOfActualPool )
23661 : {
23662 5959 : SgFunctionSymbolStorageClass* storageArray = new SgFunctionSymbolStorageClass[sizeOfActualPool] ;
23663 3 : storageClassIndex = SgFunctionSymbol::initializeStorageClassArray (storageArray); ;
23664 3 : assert ( storageClassIndex == sizeOfActualPool );
23665 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionSymbolStorageClass ) * sizeOfActualPool) ;
23666 3 : delete [] storageArray;
23667 3 : SgFunctionSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
23668 : }
23669 :
23670 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionType );
23671 3 : storageClassIndex = 0 ;
23672 3 : if ( 0 < sizeOfActualPool )
23673 : {
23674 3153 : SgFunctionTypeStorageClass* storageArray = new SgFunctionTypeStorageClass[sizeOfActualPool] ;
23675 3 : storageClassIndex = SgFunctionType::initializeStorageClassArray (storageArray); ;
23676 3 : assert ( storageClassIndex == sizeOfActualPool );
23677 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionTypeStorageClass ) * sizeOfActualPool) ;
23678 3 : delete [] storageArray;
23679 3 : SgFunctionTypeStorageClass :: writeEasyStorageDataToFile(out) ;
23680 : }
23681 :
23682 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionTypeSymbol );
23683 3 : storageClassIndex = 0 ;
23684 3 : if ( 0 < sizeOfActualPool )
23685 : {
23686 9186 : SgFunctionTypeSymbolStorageClass* storageArray = new SgFunctionTypeSymbolStorageClass[sizeOfActualPool] ;
23687 3 : storageClassIndex = SgFunctionTypeSymbol::initializeStorageClassArray (storageArray); ;
23688 3 : assert ( storageClassIndex == sizeOfActualPool );
23689 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionTypeSymbolStorageClass ) * sizeOfActualPool) ;
23690 3 : delete [] storageArray;
23691 3 : SgFunctionTypeSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
23692 : }
23693 :
23694 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgFunctionTypeTable );
23695 3 : storageClassIndex = 0 ;
23696 3 : if ( 0 < sizeOfActualPool )
23697 : {
23698 6 : SgFunctionTypeTableStorageClass* storageArray = new SgFunctionTypeTableStorageClass[sizeOfActualPool] ;
23699 3 : storageClassIndex = SgFunctionTypeTable::initializeStorageClassArray (storageArray); ;
23700 3 : assert ( storageClassIndex == sizeOfActualPool );
23701 3 : out.write ( (char*) (storageArray) , sizeof ( SgFunctionTypeTableStorageClass ) * sizeOfActualPool) ;
23702 3 : delete [] storageArray;
23703 3 : SgFunctionTypeTableStorageClass :: writeEasyStorageDataToFile(out) ;
23704 : }
23705 :
23706 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeTable );
23707 3 : storageClassIndex = 0 ;
23708 3 : if ( 0 < sizeOfActualPool )
23709 : {
23710 3 : SgTypeTableStorageClass* storageArray = new SgTypeTableStorageClass[sizeOfActualPool] ;
23711 3 : storageClassIndex = SgTypeTable::initializeStorageClassArray (storageArray); ;
23712 3 : assert ( storageClassIndex == sizeOfActualPool );
23713 3 : out.write ( (char*) (storageArray) , sizeof ( SgTypeTableStorageClass ) * sizeOfActualPool) ;
23714 3 : delete [] storageArray;
23715 : }
23716 :
23717 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGlobal );
23718 3 : storageClassIndex = 0 ;
23719 3 : if ( 0 < sizeOfActualPool )
23720 : {
23721 9 : SgGlobalStorageClass* storageArray = new SgGlobalStorageClass[sizeOfActualPool] ;
23722 3 : storageClassIndex = SgGlobal::initializeStorageClassArray (storageArray); ;
23723 3 : assert ( storageClassIndex == sizeOfActualPool );
23724 3 : out.write ( (char*) (storageArray) , sizeof ( SgGlobalStorageClass ) * sizeOfActualPool) ;
23725 3 : delete [] storageArray;
23726 3 : SgGlobalStorageClass :: writeEasyStorageDataToFile(out) ;
23727 : }
23728 :
23729 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGotoStatement );
23730 3 : storageClassIndex = 0 ;
23731 3 : if ( 0 < sizeOfActualPool )
23732 : {
23733 0 : SgGotoStatementStorageClass* storageArray = new SgGotoStatementStorageClass[sizeOfActualPool] ;
23734 0 : storageClassIndex = SgGotoStatement::initializeStorageClassArray (storageArray); ;
23735 0 : assert ( storageClassIndex == sizeOfActualPool );
23736 0 : out.write ( (char*) (storageArray) , sizeof ( SgGotoStatementStorageClass ) * sizeOfActualPool) ;
23737 0 : delete [] storageArray;
23738 0 : SgGotoStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23739 : }
23740 :
23741 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGraph );
23742 3 : storageClassIndex = 0 ;
23743 3 : if ( 0 < sizeOfActualPool )
23744 : {
23745 0 : SgGraphStorageClass* storageArray = new SgGraphStorageClass[sizeOfActualPool] ;
23746 0 : storageClassIndex = SgGraph::initializeStorageClassArray (storageArray); ;
23747 0 : assert ( storageClassIndex == sizeOfActualPool );
23748 0 : out.write ( (char*) (storageArray) , sizeof ( SgGraphStorageClass ) * sizeOfActualPool) ;
23749 0 : delete [] storageArray;
23750 0 : SgGraphStorageClass :: writeEasyStorageDataToFile(out) ;
23751 : }
23752 :
23753 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGraphEdge );
23754 3 : storageClassIndex = 0 ;
23755 3 : if ( 0 < sizeOfActualPool )
23756 : {
23757 0 : SgGraphEdgeStorageClass* storageArray = new SgGraphEdgeStorageClass[sizeOfActualPool] ;
23758 0 : storageClassIndex = SgGraphEdge::initializeStorageClassArray (storageArray); ;
23759 0 : assert ( storageClassIndex == sizeOfActualPool );
23760 0 : out.write ( (char*) (storageArray) , sizeof ( SgGraphEdgeStorageClass ) * sizeOfActualPool) ;
23761 0 : delete [] storageArray;
23762 0 : SgGraphEdgeStorageClass :: writeEasyStorageDataToFile(out) ;
23763 : }
23764 :
23765 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGraphEdgeList );
23766 3 : storageClassIndex = 0 ;
23767 3 : if ( 0 < sizeOfActualPool )
23768 : {
23769 0 : SgGraphEdgeListStorageClass* storageArray = new SgGraphEdgeListStorageClass[sizeOfActualPool] ;
23770 0 : storageClassIndex = SgGraphEdgeList::initializeStorageClassArray (storageArray); ;
23771 0 : assert ( storageClassIndex == sizeOfActualPool );
23772 0 : out.write ( (char*) (storageArray) , sizeof ( SgGraphEdgeListStorageClass ) * sizeOfActualPool) ;
23773 0 : delete [] storageArray;
23774 : }
23775 :
23776 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGraphNode );
23777 3 : storageClassIndex = 0 ;
23778 3 : if ( 0 < sizeOfActualPool )
23779 : {
23780 0 : SgGraphNodeStorageClass* storageArray = new SgGraphNodeStorageClass[sizeOfActualPool] ;
23781 0 : storageClassIndex = SgGraphNode::initializeStorageClassArray (storageArray); ;
23782 0 : assert ( storageClassIndex == sizeOfActualPool );
23783 0 : out.write ( (char*) (storageArray) , sizeof ( SgGraphNodeStorageClass ) * sizeOfActualPool) ;
23784 0 : delete [] storageArray;
23785 0 : SgGraphNodeStorageClass :: writeEasyStorageDataToFile(out) ;
23786 : }
23787 :
23788 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGraphNodeList );
23789 3 : storageClassIndex = 0 ;
23790 3 : if ( 0 < sizeOfActualPool )
23791 : {
23792 0 : SgGraphNodeListStorageClass* storageArray = new SgGraphNodeListStorageClass[sizeOfActualPool] ;
23793 0 : storageClassIndex = SgGraphNodeList::initializeStorageClassArray (storageArray); ;
23794 0 : assert ( storageClassIndex == sizeOfActualPool );
23795 0 : out.write ( (char*) (storageArray) , sizeof ( SgGraphNodeListStorageClass ) * sizeOfActualPool) ;
23796 0 : delete [] storageArray;
23797 : }
23798 :
23799 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGreaterOrEqualOp );
23800 3 : storageClassIndex = 0 ;
23801 3 : if ( 0 < sizeOfActualPool )
23802 : {
23803 29 : SgGreaterOrEqualOpStorageClass* storageArray = new SgGreaterOrEqualOpStorageClass[sizeOfActualPool] ;
23804 1 : storageClassIndex = SgGreaterOrEqualOp::initializeStorageClassArray (storageArray); ;
23805 1 : assert ( storageClassIndex == sizeOfActualPool );
23806 1 : out.write ( (char*) (storageArray) , sizeof ( SgGreaterOrEqualOpStorageClass ) * sizeOfActualPool) ;
23807 1 : delete [] storageArray;
23808 1 : SgGreaterOrEqualOpStorageClass :: writeEasyStorageDataToFile(out) ;
23809 : }
23810 :
23811 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgGreaterThanOp );
23812 3 : storageClassIndex = 0 ;
23813 3 : if ( 0 < sizeOfActualPool )
23814 : {
23815 109 : SgGreaterThanOpStorageClass* storageArray = new SgGreaterThanOpStorageClass[sizeOfActualPool] ;
23816 1 : storageClassIndex = SgGreaterThanOp::initializeStorageClassArray (storageArray); ;
23817 1 : assert ( storageClassIndex == sizeOfActualPool );
23818 1 : out.write ( (char*) (storageArray) , sizeof ( SgGreaterThanOpStorageClass ) * sizeOfActualPool) ;
23819 1 : delete [] storageArray;
23820 1 : SgGreaterThanOpStorageClass :: writeEasyStorageDataToFile(out) ;
23821 : }
23822 :
23823 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIOItemExpression );
23824 3 : storageClassIndex = 0 ;
23825 3 : if ( 0 < sizeOfActualPool )
23826 : {
23827 0 : SgIOItemExpressionStorageClass* storageArray = new SgIOItemExpressionStorageClass[sizeOfActualPool] ;
23828 0 : storageClassIndex = SgIOItemExpression::initializeStorageClassArray (storageArray); ;
23829 0 : assert ( storageClassIndex == sizeOfActualPool );
23830 0 : out.write ( (char*) (storageArray) , sizeof ( SgIOItemExpressionStorageClass ) * sizeOfActualPool) ;
23831 0 : delete [] storageArray;
23832 0 : SgIOItemExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
23833 : }
23834 :
23835 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIOStatement );
23836 3 : storageClassIndex = 0 ;
23837 3 : if ( 0 < sizeOfActualPool )
23838 : {
23839 0 : SgIOStatementStorageClass* storageArray = new SgIOStatementStorageClass[sizeOfActualPool] ;
23840 0 : storageClassIndex = SgIOStatement::initializeStorageClassArray (storageArray); ;
23841 0 : assert ( storageClassIndex == sizeOfActualPool );
23842 0 : out.write ( (char*) (storageArray) , sizeof ( SgIOStatementStorageClass ) * sizeOfActualPool) ;
23843 0 : delete [] storageArray;
23844 0 : SgIOStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23845 : }
23846 :
23847 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIdentDirectiveStatement );
23848 3 : storageClassIndex = 0 ;
23849 3 : if ( 0 < sizeOfActualPool )
23850 : {
23851 0 : SgIdentDirectiveStatementStorageClass* storageArray = new SgIdentDirectiveStatementStorageClass[sizeOfActualPool] ;
23852 0 : storageClassIndex = SgIdentDirectiveStatement::initializeStorageClassArray (storageArray); ;
23853 0 : assert ( storageClassIndex == sizeOfActualPool );
23854 0 : out.write ( (char*) (storageArray) , sizeof ( SgIdentDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23855 0 : delete [] storageArray;
23856 0 : SgIdentDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23857 : }
23858 :
23859 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIfDirectiveStatement );
23860 3 : storageClassIndex = 0 ;
23861 3 : if ( 0 < sizeOfActualPool )
23862 : {
23863 0 : SgIfDirectiveStatementStorageClass* storageArray = new SgIfDirectiveStatementStorageClass[sizeOfActualPool] ;
23864 0 : storageClassIndex = SgIfDirectiveStatement::initializeStorageClassArray (storageArray); ;
23865 0 : assert ( storageClassIndex == sizeOfActualPool );
23866 0 : out.write ( (char*) (storageArray) , sizeof ( SgIfDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23867 0 : delete [] storageArray;
23868 0 : SgIfDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23869 : }
23870 :
23871 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIfStmt );
23872 3 : storageClassIndex = 0 ;
23873 3 : if ( 0 < sizeOfActualPool )
23874 : {
23875 593 : SgIfStmtStorageClass* storageArray = new SgIfStmtStorageClass[sizeOfActualPool] ;
23876 1 : storageClassIndex = SgIfStmt::initializeStorageClassArray (storageArray); ;
23877 1 : assert ( storageClassIndex == sizeOfActualPool );
23878 1 : out.write ( (char*) (storageArray) , sizeof ( SgIfStmtStorageClass ) * sizeOfActualPool) ;
23879 1 : delete [] storageArray;
23880 1 : SgIfStmtStorageClass :: writeEasyStorageDataToFile(out) ;
23881 : }
23882 :
23883 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIfdefDirectiveStatement );
23884 3 : storageClassIndex = 0 ;
23885 3 : if ( 0 < sizeOfActualPool )
23886 : {
23887 0 : SgIfdefDirectiveStatementStorageClass* storageArray = new SgIfdefDirectiveStatementStorageClass[sizeOfActualPool] ;
23888 0 : storageClassIndex = SgIfdefDirectiveStatement::initializeStorageClassArray (storageArray); ;
23889 0 : assert ( storageClassIndex == sizeOfActualPool );
23890 0 : out.write ( (char*) (storageArray) , sizeof ( SgIfdefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23891 0 : delete [] storageArray;
23892 0 : SgIfdefDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23893 : }
23894 :
23895 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIfndefDirectiveStatement );
23896 3 : storageClassIndex = 0 ;
23897 3 : if ( 0 < sizeOfActualPool )
23898 : {
23899 0 : SgIfndefDirectiveStatementStorageClass* storageArray = new SgIfndefDirectiveStatementStorageClass[sizeOfActualPool] ;
23900 0 : storageClassIndex = SgIfndefDirectiveStatement::initializeStorageClassArray (storageArray); ;
23901 0 : assert ( storageClassIndex == sizeOfActualPool );
23902 0 : out.write ( (char*) (storageArray) , sizeof ( SgIfndefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23903 0 : delete [] storageArray;
23904 0 : SgIfndefDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23905 : }
23906 :
23907 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgImageControlStatement );
23908 3 : storageClassIndex = 0 ;
23909 3 : if ( 0 < sizeOfActualPool )
23910 : {
23911 0 : SgImageControlStatementStorageClass* storageArray = new SgImageControlStatementStorageClass[sizeOfActualPool] ;
23912 0 : storageClassIndex = SgImageControlStatement::initializeStorageClassArray (storageArray); ;
23913 0 : assert ( storageClassIndex == sizeOfActualPool );
23914 0 : out.write ( (char*) (storageArray) , sizeof ( SgImageControlStatementStorageClass ) * sizeOfActualPool) ;
23915 0 : delete [] storageArray;
23916 0 : SgImageControlStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23917 : }
23918 :
23919 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgImagPartOp );
23920 3 : storageClassIndex = 0 ;
23921 3 : if ( 0 < sizeOfActualPool )
23922 : {
23923 0 : SgImagPartOpStorageClass* storageArray = new SgImagPartOpStorageClass[sizeOfActualPool] ;
23924 0 : storageClassIndex = SgImagPartOp::initializeStorageClassArray (storageArray); ;
23925 0 : assert ( storageClassIndex == sizeOfActualPool );
23926 0 : out.write ( (char*) (storageArray) , sizeof ( SgImagPartOpStorageClass ) * sizeOfActualPool) ;
23927 0 : delete [] storageArray;
23928 0 : SgImagPartOpStorageClass :: writeEasyStorageDataToFile(out) ;
23929 : }
23930 :
23931 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgImplicitStatement );
23932 3 : storageClassIndex = 0 ;
23933 3 : if ( 0 < sizeOfActualPool )
23934 : {
23935 0 : SgImplicitStatementStorageClass* storageArray = new SgImplicitStatementStorageClass[sizeOfActualPool] ;
23936 0 : storageClassIndex = SgImplicitStatement::initializeStorageClassArray (storageArray); ;
23937 0 : assert ( storageClassIndex == sizeOfActualPool );
23938 0 : out.write ( (char*) (storageArray) , sizeof ( SgImplicitStatementStorageClass ) * sizeOfActualPool) ;
23939 0 : delete [] storageArray;
23940 0 : SgImplicitStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23941 : }
23942 :
23943 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgImpliedDo );
23944 3 : storageClassIndex = 0 ;
23945 3 : if ( 0 < sizeOfActualPool )
23946 : {
23947 0 : SgImpliedDoStorageClass* storageArray = new SgImpliedDoStorageClass[sizeOfActualPool] ;
23948 0 : storageClassIndex = SgImpliedDo::initializeStorageClassArray (storageArray); ;
23949 0 : assert ( storageClassIndex == sizeOfActualPool );
23950 0 : out.write ( (char*) (storageArray) , sizeof ( SgImpliedDoStorageClass ) * sizeOfActualPool) ;
23951 0 : delete [] storageArray;
23952 0 : SgImpliedDoStorageClass :: writeEasyStorageDataToFile(out) ;
23953 : }
23954 :
23955 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgImportStatement );
23956 3 : storageClassIndex = 0 ;
23957 3 : if ( 0 < sizeOfActualPool )
23958 : {
23959 0 : SgImportStatementStorageClass* storageArray = new SgImportStatementStorageClass[sizeOfActualPool] ;
23960 0 : storageClassIndex = SgImportStatement::initializeStorageClassArray (storageArray); ;
23961 0 : assert ( storageClassIndex == sizeOfActualPool );
23962 0 : out.write ( (char*) (storageArray) , sizeof ( SgImportStatementStorageClass ) * sizeOfActualPool) ;
23963 0 : delete [] storageArray;
23964 0 : SgImportStatementStorageClass :: writeEasyStorageDataToFile(out) ;
23965 : }
23966 :
23967 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIncidenceDirectedGraph );
23968 3 : storageClassIndex = 0 ;
23969 3 : if ( 0 < sizeOfActualPool )
23970 : {
23971 0 : SgIncidenceDirectedGraphStorageClass* storageArray = new SgIncidenceDirectedGraphStorageClass[sizeOfActualPool] ;
23972 0 : storageClassIndex = SgIncidenceDirectedGraph::initializeStorageClassArray (storageArray); ;
23973 0 : assert ( storageClassIndex == sizeOfActualPool );
23974 0 : out.write ( (char*) (storageArray) , sizeof ( SgIncidenceDirectedGraphStorageClass ) * sizeOfActualPool) ;
23975 0 : delete [] storageArray;
23976 0 : SgIncidenceDirectedGraphStorageClass :: writeEasyStorageDataToFile(out) ;
23977 : }
23978 :
23979 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIncidenceUndirectedGraph );
23980 3 : storageClassIndex = 0 ;
23981 3 : if ( 0 < sizeOfActualPool )
23982 : {
23983 0 : SgIncidenceUndirectedGraphStorageClass* storageArray = new SgIncidenceUndirectedGraphStorageClass[sizeOfActualPool] ;
23984 0 : storageClassIndex = SgIncidenceUndirectedGraph::initializeStorageClassArray (storageArray); ;
23985 0 : assert ( storageClassIndex == sizeOfActualPool );
23986 0 : out.write ( (char*) (storageArray) , sizeof ( SgIncidenceUndirectedGraphStorageClass ) * sizeOfActualPool) ;
23987 0 : delete [] storageArray;
23988 0 : SgIncidenceUndirectedGraphStorageClass :: writeEasyStorageDataToFile(out) ;
23989 : }
23990 :
23991 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIncludeDirectiveStatement );
23992 3 : storageClassIndex = 0 ;
23993 3 : if ( 0 < sizeOfActualPool )
23994 : {
23995 0 : SgIncludeDirectiveStatementStorageClass* storageArray = new SgIncludeDirectiveStatementStorageClass[sizeOfActualPool] ;
23996 0 : storageClassIndex = SgIncludeDirectiveStatement::initializeStorageClassArray (storageArray); ;
23997 0 : assert ( storageClassIndex == sizeOfActualPool );
23998 0 : out.write ( (char*) (storageArray) , sizeof ( SgIncludeDirectiveStatementStorageClass ) * sizeOfActualPool) ;
23999 0 : delete [] storageArray;
24000 0 : SgIncludeDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24001 : }
24002 :
24003 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIncludeFile );
24004 3 : storageClassIndex = 0 ;
24005 3 : if ( 0 < sizeOfActualPool )
24006 : {
24007 226 : SgIncludeFileStorageClass* storageArray = new SgIncludeFileStorageClass[sizeOfActualPool] ;
24008 2 : storageClassIndex = SgIncludeFile::initializeStorageClassArray (storageArray); ;
24009 2 : assert ( storageClassIndex == sizeOfActualPool );
24010 2 : out.write ( (char*) (storageArray) , sizeof ( SgIncludeFileStorageClass ) * sizeOfActualPool) ;
24011 2 : delete [] storageArray;
24012 2 : SgIncludeFileStorageClass :: writeEasyStorageDataToFile(out) ;
24013 : }
24014 :
24015 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIncludeNextDirectiveStatement );
24016 3 : storageClassIndex = 0 ;
24017 3 : if ( 0 < sizeOfActualPool )
24018 : {
24019 0 : SgIncludeNextDirectiveStatementStorageClass* storageArray = new SgIncludeNextDirectiveStatementStorageClass[sizeOfActualPool] ;
24020 0 : storageClassIndex = SgIncludeNextDirectiveStatement::initializeStorageClassArray (storageArray); ;
24021 0 : assert ( storageClassIndex == sizeOfActualPool );
24022 0 : out.write ( (char*) (storageArray) , sizeof ( SgIncludeNextDirectiveStatementStorageClass ) * sizeOfActualPool) ;
24023 0 : delete [] storageArray;
24024 0 : SgIncludeNextDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24025 : }
24026 :
24027 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInitializedName );
24028 3 : storageClassIndex = 0 ;
24029 3 : if ( 0 < sizeOfActualPool )
24030 : {
24031 55227 : SgInitializedNameStorageClass* storageArray = new SgInitializedNameStorageClass[sizeOfActualPool] ;
24032 2 : storageClassIndex = SgInitializedName::initializeStorageClassArray (storageArray); ;
24033 2 : assert ( storageClassIndex == sizeOfActualPool );
24034 2 : out.write ( (char*) (storageArray) , sizeof ( SgInitializedNameStorageClass ) * sizeOfActualPool) ;
24035 2 : delete [] storageArray;
24036 2 : SgInitializedNameStorageClass :: writeEasyStorageDataToFile(out) ;
24037 : }
24038 :
24039 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInitializer );
24040 3 : storageClassIndex = 0 ;
24041 3 : if ( 0 < sizeOfActualPool )
24042 : {
24043 0 : SgInitializerStorageClass* storageArray = new SgInitializerStorageClass[sizeOfActualPool] ;
24044 0 : storageClassIndex = SgInitializer::initializeStorageClassArray (storageArray); ;
24045 0 : assert ( storageClassIndex == sizeOfActualPool );
24046 0 : out.write ( (char*) (storageArray) , sizeof ( SgInitializerStorageClass ) * sizeOfActualPool) ;
24047 0 : delete [] storageArray;
24048 0 : SgInitializerStorageClass :: writeEasyStorageDataToFile(out) ;
24049 : }
24050 :
24051 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInquireStatement );
24052 3 : storageClassIndex = 0 ;
24053 3 : if ( 0 < sizeOfActualPool )
24054 : {
24055 0 : SgInquireStatementStorageClass* storageArray = new SgInquireStatementStorageClass[sizeOfActualPool] ;
24056 0 : storageClassIndex = SgInquireStatement::initializeStorageClassArray (storageArray); ;
24057 0 : assert ( storageClassIndex == sizeOfActualPool );
24058 0 : out.write ( (char*) (storageArray) , sizeof ( SgInquireStatementStorageClass ) * sizeOfActualPool) ;
24059 0 : delete [] storageArray;
24060 0 : SgInquireStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24061 : }
24062 :
24063 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIntKeyedBidirectionalGraph );
24064 3 : storageClassIndex = 0 ;
24065 3 : if ( 0 < sizeOfActualPool )
24066 : {
24067 0 : SgIntKeyedBidirectionalGraphStorageClass* storageArray = new SgIntKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
24068 0 : storageClassIndex = SgIntKeyedBidirectionalGraph::initializeStorageClassArray (storageArray); ;
24069 0 : assert ( storageClassIndex == sizeOfActualPool );
24070 0 : out.write ( (char*) (storageArray) , sizeof ( SgIntKeyedBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
24071 0 : delete [] storageArray;
24072 0 : SgIntKeyedBidirectionalGraphStorageClass :: writeEasyStorageDataToFile(out) ;
24073 : }
24074 :
24075 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIntVal );
24076 3 : storageClassIndex = 0 ;
24077 3 : if ( 0 < sizeOfActualPool )
24078 : {
24079 927 : SgIntValStorageClass* storageArray = new SgIntValStorageClass[sizeOfActualPool] ;
24080 2 : storageClassIndex = SgIntVal::initializeStorageClassArray (storageArray); ;
24081 2 : assert ( storageClassIndex == sizeOfActualPool );
24082 2 : out.write ( (char*) (storageArray) , sizeof ( SgIntValStorageClass ) * sizeOfActualPool) ;
24083 2 : delete [] storageArray;
24084 2 : SgIntValStorageClass :: writeEasyStorageDataToFile(out) ;
24085 : }
24086 :
24087 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIntegerDivideOp );
24088 3 : storageClassIndex = 0 ;
24089 3 : if ( 0 < sizeOfActualPool )
24090 : {
24091 0 : SgIntegerDivideOpStorageClass* storageArray = new SgIntegerDivideOpStorageClass[sizeOfActualPool] ;
24092 0 : storageClassIndex = SgIntegerDivideOp::initializeStorageClassArray (storageArray); ;
24093 0 : assert ( storageClassIndex == sizeOfActualPool );
24094 0 : out.write ( (char*) (storageArray) , sizeof ( SgIntegerDivideOpStorageClass ) * sizeOfActualPool) ;
24095 0 : delete [] storageArray;
24096 0 : SgIntegerDivideOpStorageClass :: writeEasyStorageDataToFile(out) ;
24097 : }
24098 :
24099 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIntegerDivideAssignOp );
24100 3 : storageClassIndex = 0 ;
24101 3 : if ( 0 < sizeOfActualPool )
24102 : {
24103 0 : SgIntegerDivideAssignOpStorageClass* storageArray = new SgIntegerDivideAssignOpStorageClass[sizeOfActualPool] ;
24104 0 : storageClassIndex = SgIntegerDivideAssignOp::initializeStorageClassArray (storageArray); ;
24105 0 : assert ( storageClassIndex == sizeOfActualPool );
24106 0 : out.write ( (char*) (storageArray) , sizeof ( SgIntegerDivideAssignOpStorageClass ) * sizeOfActualPool) ;
24107 0 : delete [] storageArray;
24108 0 : SgIntegerDivideAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24109 : }
24110 :
24111 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInterfaceBody );
24112 3 : storageClassIndex = 0 ;
24113 3 : if ( 0 < sizeOfActualPool )
24114 : {
24115 0 : SgInterfaceBodyStorageClass* storageArray = new SgInterfaceBodyStorageClass[sizeOfActualPool] ;
24116 0 : storageClassIndex = SgInterfaceBody::initializeStorageClassArray (storageArray); ;
24117 0 : assert ( storageClassIndex == sizeOfActualPool );
24118 0 : out.write ( (char*) (storageArray) , sizeof ( SgInterfaceBodyStorageClass ) * sizeOfActualPool) ;
24119 0 : delete [] storageArray;
24120 0 : SgInterfaceBodyStorageClass :: writeEasyStorageDataToFile(out) ;
24121 : }
24122 :
24123 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgHeaderFileBody );
24124 3 : storageClassIndex = 0 ;
24125 3 : if ( 0 < sizeOfActualPool )
24126 : {
24127 0 : SgHeaderFileBodyStorageClass* storageArray = new SgHeaderFileBodyStorageClass[sizeOfActualPool] ;
24128 0 : storageClassIndex = SgHeaderFileBody::initializeStorageClassArray (storageArray); ;
24129 0 : assert ( storageClassIndex == sizeOfActualPool );
24130 0 : out.write ( (char*) (storageArray) , sizeof ( SgHeaderFileBodyStorageClass ) * sizeOfActualPool) ;
24131 0 : delete [] storageArray;
24132 0 : SgHeaderFileBodyStorageClass :: writeEasyStorageDataToFile(out) ;
24133 : }
24134 :
24135 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgHeaderFileReport );
24136 3 : storageClassIndex = 0 ;
24137 3 : if ( 0 < sizeOfActualPool )
24138 : {
24139 0 : SgHeaderFileReportStorageClass* storageArray = new SgHeaderFileReportStorageClass[sizeOfActualPool] ;
24140 0 : storageClassIndex = SgHeaderFileReport::initializeStorageClassArray (storageArray); ;
24141 0 : assert ( storageClassIndex == sizeOfActualPool );
24142 0 : out.write ( (char*) (storageArray) , sizeof ( SgHeaderFileReportStorageClass ) * sizeOfActualPool) ;
24143 0 : delete [] storageArray;
24144 0 : SgHeaderFileReportStorageClass :: writeEasyStorageDataToFile(out) ;
24145 : }
24146 :
24147 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInterfaceStatement );
24148 3 : storageClassIndex = 0 ;
24149 3 : if ( 0 < sizeOfActualPool )
24150 : {
24151 0 : SgInterfaceStatementStorageClass* storageArray = new SgInterfaceStatementStorageClass[sizeOfActualPool] ;
24152 0 : storageClassIndex = SgInterfaceStatement::initializeStorageClassArray (storageArray); ;
24153 0 : assert ( storageClassIndex == sizeOfActualPool );
24154 0 : out.write ( (char*) (storageArray) , sizeof ( SgInterfaceStatementStorageClass ) * sizeOfActualPool) ;
24155 0 : delete [] storageArray;
24156 0 : SgInterfaceStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24157 : }
24158 :
24159 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgInterfaceSymbol );
24160 3 : storageClassIndex = 0 ;
24161 3 : if ( 0 < sizeOfActualPool )
24162 : {
24163 0 : SgInterfaceSymbolStorageClass* storageArray = new SgInterfaceSymbolStorageClass[sizeOfActualPool] ;
24164 0 : storageClassIndex = SgInterfaceSymbol::initializeStorageClassArray (storageArray); ;
24165 0 : assert ( storageClassIndex == sizeOfActualPool );
24166 0 : out.write ( (char*) (storageArray) , sizeof ( SgInterfaceSymbolStorageClass ) * sizeOfActualPool) ;
24167 0 : delete [] storageArray;
24168 0 : SgInterfaceSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24169 : }
24170 :
24171 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIntrinsicSymbol );
24172 3 : storageClassIndex = 0 ;
24173 3 : if ( 0 < sizeOfActualPool )
24174 : {
24175 0 : SgIntrinsicSymbolStorageClass* storageArray = new SgIntrinsicSymbolStorageClass[sizeOfActualPool] ;
24176 0 : storageClassIndex = SgIntrinsicSymbol::initializeStorageClassArray (storageArray); ;
24177 0 : assert ( storageClassIndex == sizeOfActualPool );
24178 0 : out.write ( (char*) (storageArray) , sizeof ( SgIntrinsicSymbolStorageClass ) * sizeOfActualPool) ;
24179 0 : delete [] storageArray;
24180 0 : SgIntrinsicSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24181 : }
24182 :
24183 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIsOp );
24184 3 : storageClassIndex = 0 ;
24185 3 : if ( 0 < sizeOfActualPool )
24186 : {
24187 0 : SgIsOpStorageClass* storageArray = new SgIsOpStorageClass[sizeOfActualPool] ;
24188 0 : storageClassIndex = SgIsOp::initializeStorageClassArray (storageArray); ;
24189 0 : assert ( storageClassIndex == sizeOfActualPool );
24190 0 : out.write ( (char*) (storageArray) , sizeof ( SgIsOpStorageClass ) * sizeOfActualPool) ;
24191 0 : delete [] storageArray;
24192 0 : SgIsOpStorageClass :: writeEasyStorageDataToFile(out) ;
24193 : }
24194 :
24195 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIsNotOp );
24196 3 : storageClassIndex = 0 ;
24197 3 : if ( 0 < sizeOfActualPool )
24198 : {
24199 0 : SgIsNotOpStorageClass* storageArray = new SgIsNotOpStorageClass[sizeOfActualPool] ;
24200 0 : storageClassIndex = SgIsNotOp::initializeStorageClassArray (storageArray); ;
24201 0 : assert ( storageClassIndex == sizeOfActualPool );
24202 0 : out.write ( (char*) (storageArray) , sizeof ( SgIsNotOpStorageClass ) * sizeOfActualPool) ;
24203 0 : delete [] storageArray;
24204 0 : SgIsNotOpStorageClass :: writeEasyStorageDataToFile(out) ;
24205 : }
24206 :
24207 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgIorAssignOp );
24208 3 : storageClassIndex = 0 ;
24209 3 : if ( 0 < sizeOfActualPool )
24210 : {
24211 8 : SgIorAssignOpStorageClass* storageArray = new SgIorAssignOpStorageClass[sizeOfActualPool] ;
24212 1 : storageClassIndex = SgIorAssignOp::initializeStorageClassArray (storageArray); ;
24213 1 : assert ( storageClassIndex == sizeOfActualPool );
24214 1 : out.write ( (char*) (storageArray) , sizeof ( SgIorAssignOpStorageClass ) * sizeOfActualPool) ;
24215 1 : delete [] storageArray;
24216 1 : SgIorAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24217 : }
24218 :
24219 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgKeyDatumPair );
24220 3 : storageClassIndex = 0 ;
24221 3 : if ( 0 < sizeOfActualPool )
24222 : {
24223 0 : SgKeyDatumPairStorageClass* storageArray = new SgKeyDatumPairStorageClass[sizeOfActualPool] ;
24224 0 : storageClassIndex = SgKeyDatumPair::initializeStorageClassArray (storageArray); ;
24225 0 : assert ( storageClassIndex == sizeOfActualPool );
24226 0 : out.write ( (char*) (storageArray) , sizeof ( SgKeyDatumPairStorageClass ) * sizeOfActualPool) ;
24227 0 : delete [] storageArray;
24228 0 : SgKeyDatumPairStorageClass :: writeEasyStorageDataToFile(out) ;
24229 : }
24230 :
24231 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCudaKernelExecConfig );
24232 3 : storageClassIndex = 0 ;
24233 3 : if ( 0 < sizeOfActualPool )
24234 : {
24235 0 : SgCudaKernelExecConfigStorageClass* storageArray = new SgCudaKernelExecConfigStorageClass[sizeOfActualPool] ;
24236 0 : storageClassIndex = SgCudaKernelExecConfig::initializeStorageClassArray (storageArray); ;
24237 0 : assert ( storageClassIndex == sizeOfActualPool );
24238 0 : out.write ( (char*) (storageArray) , sizeof ( SgCudaKernelExecConfigStorageClass ) * sizeOfActualPool) ;
24239 0 : delete [] storageArray;
24240 0 : SgCudaKernelExecConfigStorageClass :: writeEasyStorageDataToFile(out) ;
24241 : }
24242 :
24243 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCudaKernelCallExp );
24244 3 : storageClassIndex = 0 ;
24245 3 : if ( 0 < sizeOfActualPool )
24246 : {
24247 0 : SgCudaKernelCallExpStorageClass* storageArray = new SgCudaKernelCallExpStorageClass[sizeOfActualPool] ;
24248 0 : storageClassIndex = SgCudaKernelCallExp::initializeStorageClassArray (storageArray); ;
24249 0 : assert ( storageClassIndex == sizeOfActualPool );
24250 0 : out.write ( (char*) (storageArray) , sizeof ( SgCudaKernelCallExpStorageClass ) * sizeOfActualPool) ;
24251 0 : delete [] storageArray;
24252 0 : SgCudaKernelCallExpStorageClass :: writeEasyStorageDataToFile(out) ;
24253 : }
24254 :
24255 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLabelRefExp );
24256 3 : storageClassIndex = 0 ;
24257 3 : if ( 0 < sizeOfActualPool )
24258 : {
24259 0 : SgLabelRefExpStorageClass* storageArray = new SgLabelRefExpStorageClass[sizeOfActualPool] ;
24260 0 : storageClassIndex = SgLabelRefExp::initializeStorageClassArray (storageArray); ;
24261 0 : assert ( storageClassIndex == sizeOfActualPool );
24262 0 : out.write ( (char*) (storageArray) , sizeof ( SgLabelRefExpStorageClass ) * sizeOfActualPool) ;
24263 0 : delete [] storageArray;
24264 0 : SgLabelRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
24265 : }
24266 :
24267 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLabelStatement );
24268 3 : storageClassIndex = 0 ;
24269 3 : if ( 0 < sizeOfActualPool )
24270 : {
24271 0 : SgLabelStatementStorageClass* storageArray = new SgLabelStatementStorageClass[sizeOfActualPool] ;
24272 0 : storageClassIndex = SgLabelStatement::initializeStorageClassArray (storageArray); ;
24273 0 : assert ( storageClassIndex == sizeOfActualPool );
24274 0 : out.write ( (char*) (storageArray) , sizeof ( SgLabelStatementStorageClass ) * sizeOfActualPool) ;
24275 0 : delete [] storageArray;
24276 0 : SgLabelStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24277 : }
24278 :
24279 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLabelSymbol );
24280 3 : storageClassIndex = 0 ;
24281 3 : if ( 0 < sizeOfActualPool )
24282 : {
24283 0 : SgLabelSymbolStorageClass* storageArray = new SgLabelSymbolStorageClass[sizeOfActualPool] ;
24284 0 : storageClassIndex = SgLabelSymbol::initializeStorageClassArray (storageArray); ;
24285 0 : assert ( storageClassIndex == sizeOfActualPool );
24286 0 : out.write ( (char*) (storageArray) , sizeof ( SgLabelSymbolStorageClass ) * sizeOfActualPool) ;
24287 0 : delete [] storageArray;
24288 0 : SgLabelSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24289 : }
24290 :
24291 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLambdaCapture );
24292 3 : storageClassIndex = 0 ;
24293 3 : if ( 0 < sizeOfActualPool )
24294 : {
24295 0 : SgLambdaCaptureStorageClass* storageArray = new SgLambdaCaptureStorageClass[sizeOfActualPool] ;
24296 0 : storageClassIndex = SgLambdaCapture::initializeStorageClassArray (storageArray); ;
24297 0 : assert ( storageClassIndex == sizeOfActualPool );
24298 0 : out.write ( (char*) (storageArray) , sizeof ( SgLambdaCaptureStorageClass ) * sizeOfActualPool) ;
24299 0 : delete [] storageArray;
24300 0 : SgLambdaCaptureStorageClass :: writeEasyStorageDataToFile(out) ;
24301 : }
24302 :
24303 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLambdaCaptureList );
24304 3 : storageClassIndex = 0 ;
24305 3 : if ( 0 < sizeOfActualPool )
24306 : {
24307 0 : SgLambdaCaptureListStorageClass* storageArray = new SgLambdaCaptureListStorageClass[sizeOfActualPool] ;
24308 0 : storageClassIndex = SgLambdaCaptureList::initializeStorageClassArray (storageArray); ;
24309 0 : assert ( storageClassIndex == sizeOfActualPool );
24310 0 : out.write ( (char*) (storageArray) , sizeof ( SgLambdaCaptureListStorageClass ) * sizeOfActualPool) ;
24311 0 : delete [] storageArray;
24312 0 : SgLambdaCaptureListStorageClass :: writeEasyStorageDataToFile(out) ;
24313 : }
24314 :
24315 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLambdaExp );
24316 3 : storageClassIndex = 0 ;
24317 3 : if ( 0 < sizeOfActualPool )
24318 : {
24319 0 : SgLambdaExpStorageClass* storageArray = new SgLambdaExpStorageClass[sizeOfActualPool] ;
24320 0 : storageClassIndex = SgLambdaExp::initializeStorageClassArray (storageArray); ;
24321 0 : assert ( storageClassIndex == sizeOfActualPool );
24322 0 : out.write ( (char*) (storageArray) , sizeof ( SgLambdaExpStorageClass ) * sizeOfActualPool) ;
24323 0 : delete [] storageArray;
24324 0 : SgLambdaExpStorageClass :: writeEasyStorageDataToFile(out) ;
24325 : }
24326 :
24327 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLambdaRefExp );
24328 3 : storageClassIndex = 0 ;
24329 3 : if ( 0 < sizeOfActualPool )
24330 : {
24331 0 : SgLambdaRefExpStorageClass* storageArray = new SgLambdaRefExpStorageClass[sizeOfActualPool] ;
24332 0 : storageClassIndex = SgLambdaRefExp::initializeStorageClassArray (storageArray); ;
24333 0 : assert ( storageClassIndex == sizeOfActualPool );
24334 0 : out.write ( (char*) (storageArray) , sizeof ( SgLambdaRefExpStorageClass ) * sizeOfActualPool) ;
24335 0 : delete [] storageArray;
24336 0 : SgLambdaRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
24337 : }
24338 :
24339 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLeftDivideOp );
24340 3 : storageClassIndex = 0 ;
24341 3 : if ( 0 < sizeOfActualPool )
24342 : {
24343 0 : SgLeftDivideOpStorageClass* storageArray = new SgLeftDivideOpStorageClass[sizeOfActualPool] ;
24344 0 : storageClassIndex = SgLeftDivideOp::initializeStorageClassArray (storageArray); ;
24345 0 : assert ( storageClassIndex == sizeOfActualPool );
24346 0 : out.write ( (char*) (storageArray) , sizeof ( SgLeftDivideOpStorageClass ) * sizeOfActualPool) ;
24347 0 : delete [] storageArray;
24348 0 : SgLeftDivideOpStorageClass :: writeEasyStorageDataToFile(out) ;
24349 : }
24350 :
24351 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLessOrEqualOp );
24352 3 : storageClassIndex = 0 ;
24353 3 : if ( 0 < sizeOfActualPool )
24354 : {
24355 32 : SgLessOrEqualOpStorageClass* storageArray = new SgLessOrEqualOpStorageClass[sizeOfActualPool] ;
24356 1 : storageClassIndex = SgLessOrEqualOp::initializeStorageClassArray (storageArray); ;
24357 1 : assert ( storageClassIndex == sizeOfActualPool );
24358 1 : out.write ( (char*) (storageArray) , sizeof ( SgLessOrEqualOpStorageClass ) * sizeOfActualPool) ;
24359 1 : delete [] storageArray;
24360 1 : SgLessOrEqualOpStorageClass :: writeEasyStorageDataToFile(out) ;
24361 : }
24362 :
24363 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLessThanOp );
24364 3 : storageClassIndex = 0 ;
24365 3 : if ( 0 < sizeOfActualPool )
24366 : {
24367 137 : SgLessThanOpStorageClass* storageArray = new SgLessThanOpStorageClass[sizeOfActualPool] ;
24368 1 : storageClassIndex = SgLessThanOp::initializeStorageClassArray (storageArray); ;
24369 1 : assert ( storageClassIndex == sizeOfActualPool );
24370 1 : out.write ( (char*) (storageArray) , sizeof ( SgLessThanOpStorageClass ) * sizeOfActualPool) ;
24371 1 : delete [] storageArray;
24372 1 : SgLessThanOpStorageClass :: writeEasyStorageDataToFile(out) ;
24373 : }
24374 :
24375 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLineDirectiveStatement );
24376 3 : storageClassIndex = 0 ;
24377 3 : if ( 0 < sizeOfActualPool )
24378 : {
24379 0 : SgLineDirectiveStatementStorageClass* storageArray = new SgLineDirectiveStatementStorageClass[sizeOfActualPool] ;
24380 0 : storageClassIndex = SgLineDirectiveStatement::initializeStorageClassArray (storageArray); ;
24381 0 : assert ( storageClassIndex == sizeOfActualPool );
24382 0 : out.write ( (char*) (storageArray) , sizeof ( SgLineDirectiveStatementStorageClass ) * sizeOfActualPool) ;
24383 0 : delete [] storageArray;
24384 0 : SgLineDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24385 : }
24386 :
24387 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLinemarkerDirectiveStatement );
24388 3 : storageClassIndex = 0 ;
24389 3 : if ( 0 < sizeOfActualPool )
24390 : {
24391 0 : SgLinemarkerDirectiveStatementStorageClass* storageArray = new SgLinemarkerDirectiveStatementStorageClass[sizeOfActualPool] ;
24392 0 : storageClassIndex = SgLinemarkerDirectiveStatement::initializeStorageClassArray (storageArray); ;
24393 0 : assert ( storageClassIndex == sizeOfActualPool );
24394 0 : out.write ( (char*) (storageArray) , sizeof ( SgLinemarkerDirectiveStatementStorageClass ) * sizeOfActualPool) ;
24395 0 : delete [] storageArray;
24396 0 : SgLinemarkerDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24397 : }
24398 :
24399 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLinkageModifier );
24400 3 : storageClassIndex = 0 ;
24401 3 : if ( 0 < sizeOfActualPool )
24402 : {
24403 0 : SgLinkageModifierStorageClass* storageArray = new SgLinkageModifierStorageClass[sizeOfActualPool] ;
24404 0 : storageClassIndex = SgLinkageModifier::initializeStorageClassArray (storageArray); ;
24405 0 : assert ( storageClassIndex == sizeOfActualPool );
24406 0 : out.write ( (char*) (storageArray) , sizeof ( SgLinkageModifierStorageClass ) * sizeOfActualPool) ;
24407 0 : delete [] storageArray;
24408 : }
24409 :
24410 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgListComprehension );
24411 3 : storageClassIndex = 0 ;
24412 3 : if ( 0 < sizeOfActualPool )
24413 : {
24414 0 : SgListComprehensionStorageClass* storageArray = new SgListComprehensionStorageClass[sizeOfActualPool] ;
24415 0 : storageClassIndex = SgListComprehension::initializeStorageClassArray (storageArray); ;
24416 0 : assert ( storageClassIndex == sizeOfActualPool );
24417 0 : out.write ( (char*) (storageArray) , sizeof ( SgListComprehensionStorageClass ) * sizeOfActualPool) ;
24418 0 : delete [] storageArray;
24419 0 : SgListComprehensionStorageClass :: writeEasyStorageDataToFile(out) ;
24420 : }
24421 :
24422 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgListExp );
24423 3 : storageClassIndex = 0 ;
24424 3 : if ( 0 < sizeOfActualPool )
24425 : {
24426 0 : SgListExpStorageClass* storageArray = new SgListExpStorageClass[sizeOfActualPool] ;
24427 0 : storageClassIndex = SgListExp::initializeStorageClassArray (storageArray); ;
24428 0 : assert ( storageClassIndex == sizeOfActualPool );
24429 0 : out.write ( (char*) (storageArray) , sizeof ( SgListExpStorageClass ) * sizeOfActualPool) ;
24430 0 : delete [] storageArray;
24431 0 : SgListExpStorageClass :: writeEasyStorageDataToFile(out) ;
24432 : }
24433 :
24434 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLocatedNode );
24435 3 : storageClassIndex = 0 ;
24436 3 : if ( 0 < sizeOfActualPool )
24437 : {
24438 0 : SgLocatedNodeStorageClass* storageArray = new SgLocatedNodeStorageClass[sizeOfActualPool] ;
24439 0 : storageClassIndex = SgLocatedNode::initializeStorageClassArray (storageArray); ;
24440 0 : assert ( storageClassIndex == sizeOfActualPool );
24441 0 : out.write ( (char*) (storageArray) , sizeof ( SgLocatedNodeStorageClass ) * sizeOfActualPool) ;
24442 0 : delete [] storageArray;
24443 0 : SgLocatedNodeStorageClass :: writeEasyStorageDataToFile(out) ;
24444 : }
24445 :
24446 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLocatedNodeSupport );
24447 3 : storageClassIndex = 0 ;
24448 3 : if ( 0 < sizeOfActualPool )
24449 : {
24450 0 : SgLocatedNodeSupportStorageClass* storageArray = new SgLocatedNodeSupportStorageClass[sizeOfActualPool] ;
24451 0 : storageClassIndex = SgLocatedNodeSupport::initializeStorageClassArray (storageArray); ;
24452 0 : assert ( storageClassIndex == sizeOfActualPool );
24453 0 : out.write ( (char*) (storageArray) , sizeof ( SgLocatedNodeSupportStorageClass ) * sizeOfActualPool) ;
24454 0 : delete [] storageArray;
24455 0 : SgLocatedNodeSupportStorageClass :: writeEasyStorageDataToFile(out) ;
24456 : }
24457 :
24458 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLongDoubleVal );
24459 3 : storageClassIndex = 0 ;
24460 3 : if ( 0 < sizeOfActualPool )
24461 : {
24462 0 : SgLongDoubleValStorageClass* storageArray = new SgLongDoubleValStorageClass[sizeOfActualPool] ;
24463 0 : storageClassIndex = SgLongDoubleVal::initializeStorageClassArray (storageArray); ;
24464 0 : assert ( storageClassIndex == sizeOfActualPool );
24465 0 : out.write ( (char*) (storageArray) , sizeof ( SgLongDoubleValStorageClass ) * sizeOfActualPool) ;
24466 0 : delete [] storageArray;
24467 0 : SgLongDoubleValStorageClass :: writeEasyStorageDataToFile(out) ;
24468 : }
24469 :
24470 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLongIntVal );
24471 3 : storageClassIndex = 0 ;
24472 3 : if ( 0 < sizeOfActualPool )
24473 : {
24474 14 : SgLongIntValStorageClass* storageArray = new SgLongIntValStorageClass[sizeOfActualPool] ;
24475 1 : storageClassIndex = SgLongIntVal::initializeStorageClassArray (storageArray); ;
24476 1 : assert ( storageClassIndex == sizeOfActualPool );
24477 1 : out.write ( (char*) (storageArray) , sizeof ( SgLongIntValStorageClass ) * sizeOfActualPool) ;
24478 1 : delete [] storageArray;
24479 1 : SgLongIntValStorageClass :: writeEasyStorageDataToFile(out) ;
24480 : }
24481 :
24482 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLongLongIntVal );
24483 3 : storageClassIndex = 0 ;
24484 3 : if ( 0 < sizeOfActualPool )
24485 : {
24486 0 : SgLongLongIntValStorageClass* storageArray = new SgLongLongIntValStorageClass[sizeOfActualPool] ;
24487 0 : storageClassIndex = SgLongLongIntVal::initializeStorageClassArray (storageArray); ;
24488 0 : assert ( storageClassIndex == sizeOfActualPool );
24489 0 : out.write ( (char*) (storageArray) , sizeof ( SgLongLongIntValStorageClass ) * sizeOfActualPool) ;
24490 0 : delete [] storageArray;
24491 0 : SgLongLongIntValStorageClass :: writeEasyStorageDataToFile(out) ;
24492 : }
24493 :
24494 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLshiftAssignOp );
24495 3 : storageClassIndex = 0 ;
24496 3 : if ( 0 < sizeOfActualPool )
24497 : {
24498 0 : SgLshiftAssignOpStorageClass* storageArray = new SgLshiftAssignOpStorageClass[sizeOfActualPool] ;
24499 0 : storageClassIndex = SgLshiftAssignOp::initializeStorageClassArray (storageArray); ;
24500 0 : assert ( storageClassIndex == sizeOfActualPool );
24501 0 : out.write ( (char*) (storageArray) , sizeof ( SgLshiftAssignOpStorageClass ) * sizeOfActualPool) ;
24502 0 : delete [] storageArray;
24503 0 : SgLshiftAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24504 : }
24505 :
24506 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLshiftOp );
24507 3 : storageClassIndex = 0 ;
24508 3 : if ( 0 < sizeOfActualPool )
24509 : {
24510 28 : SgLshiftOpStorageClass* storageArray = new SgLshiftOpStorageClass[sizeOfActualPool] ;
24511 1 : storageClassIndex = SgLshiftOp::initializeStorageClassArray (storageArray); ;
24512 1 : assert ( storageClassIndex == sizeOfActualPool );
24513 1 : out.write ( (char*) (storageArray) , sizeof ( SgLshiftOpStorageClass ) * sizeOfActualPool) ;
24514 1 : delete [] storageArray;
24515 1 : SgLshiftOpStorageClass :: writeEasyStorageDataToFile(out) ;
24516 : }
24517 :
24518 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMagicColonExp );
24519 3 : storageClassIndex = 0 ;
24520 3 : if ( 0 < sizeOfActualPool )
24521 : {
24522 0 : SgMagicColonExpStorageClass* storageArray = new SgMagicColonExpStorageClass[sizeOfActualPool] ;
24523 0 : storageClassIndex = SgMagicColonExp::initializeStorageClassArray (storageArray); ;
24524 0 : assert ( storageClassIndex == sizeOfActualPool );
24525 0 : out.write ( (char*) (storageArray) , sizeof ( SgMagicColonExpStorageClass ) * sizeOfActualPool) ;
24526 0 : delete [] storageArray;
24527 0 : SgMagicColonExpStorageClass :: writeEasyStorageDataToFile(out) ;
24528 : }
24529 :
24530 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMatrixExp );
24531 3 : storageClassIndex = 0 ;
24532 3 : if ( 0 < sizeOfActualPool )
24533 : {
24534 0 : SgMatrixExpStorageClass* storageArray = new SgMatrixExpStorageClass[sizeOfActualPool] ;
24535 0 : storageClassIndex = SgMatrixExp::initializeStorageClassArray (storageArray); ;
24536 0 : assert ( storageClassIndex == sizeOfActualPool );
24537 0 : out.write ( (char*) (storageArray) , sizeof ( SgMatrixExpStorageClass ) * sizeOfActualPool) ;
24538 0 : delete [] storageArray;
24539 0 : SgMatrixExpStorageClass :: writeEasyStorageDataToFile(out) ;
24540 : }
24541 :
24542 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMatrixTransposeOp );
24543 3 : storageClassIndex = 0 ;
24544 3 : if ( 0 < sizeOfActualPool )
24545 : {
24546 0 : SgMatrixTransposeOpStorageClass* storageArray = new SgMatrixTransposeOpStorageClass[sizeOfActualPool] ;
24547 0 : storageClassIndex = SgMatrixTransposeOp::initializeStorageClassArray (storageArray); ;
24548 0 : assert ( storageClassIndex == sizeOfActualPool );
24549 0 : out.write ( (char*) (storageArray) , sizeof ( SgMatrixTransposeOpStorageClass ) * sizeOfActualPool) ;
24550 0 : delete [] storageArray;
24551 0 : SgMatrixTransposeOpStorageClass :: writeEasyStorageDataToFile(out) ;
24552 : }
24553 :
24554 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMemberFunctionDeclaration );
24555 3 : storageClassIndex = 0 ;
24556 3 : if ( 0 < sizeOfActualPool )
24557 : {
24558 785 : SgMemberFunctionDeclarationStorageClass* storageArray = new SgMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
24559 1 : storageClassIndex = SgMemberFunctionDeclaration::initializeStorageClassArray (storageArray); ;
24560 1 : assert ( storageClassIndex == sizeOfActualPool );
24561 1 : out.write ( (char*) (storageArray) , sizeof ( SgMemberFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
24562 1 : delete [] storageArray;
24563 1 : SgMemberFunctionDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
24564 : }
24565 :
24566 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMemberFunctionRefExp );
24567 3 : storageClassIndex = 0 ;
24568 3 : if ( 0 < sizeOfActualPool )
24569 : {
24570 541 : SgMemberFunctionRefExpStorageClass* storageArray = new SgMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
24571 1 : storageClassIndex = SgMemberFunctionRefExp::initializeStorageClassArray (storageArray); ;
24572 1 : assert ( storageClassIndex == sizeOfActualPool );
24573 1 : out.write ( (char*) (storageArray) , sizeof ( SgMemberFunctionRefExpStorageClass ) * sizeOfActualPool) ;
24574 1 : delete [] storageArray;
24575 1 : SgMemberFunctionRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
24576 : }
24577 :
24578 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMemberFunctionSymbol );
24579 3 : storageClassIndex = 0 ;
24580 3 : if ( 0 < sizeOfActualPool )
24581 : {
24582 1954 : SgMemberFunctionSymbolStorageClass* storageArray = new SgMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
24583 1 : storageClassIndex = SgMemberFunctionSymbol::initializeStorageClassArray (storageArray); ;
24584 1 : assert ( storageClassIndex == sizeOfActualPool );
24585 1 : out.write ( (char*) (storageArray) , sizeof ( SgMemberFunctionSymbolStorageClass ) * sizeOfActualPool) ;
24586 1 : delete [] storageArray;
24587 1 : SgMemberFunctionSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24588 : }
24589 :
24590 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMemberFunctionType );
24591 3 : storageClassIndex = 0 ;
24592 3 : if ( 0 < sizeOfActualPool )
24593 : {
24594 2168 : SgMemberFunctionTypeStorageClass* storageArray = new SgMemberFunctionTypeStorageClass[sizeOfActualPool] ;
24595 1 : storageClassIndex = SgMemberFunctionType::initializeStorageClassArray (storageArray); ;
24596 1 : assert ( storageClassIndex == sizeOfActualPool );
24597 1 : out.write ( (char*) (storageArray) , sizeof ( SgMemberFunctionTypeStorageClass ) * sizeOfActualPool) ;
24598 1 : delete [] storageArray;
24599 1 : SgMemberFunctionTypeStorageClass :: writeEasyStorageDataToFile(out) ;
24600 : }
24601 :
24602 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMembershipOp );
24603 3 : storageClassIndex = 0 ;
24604 3 : if ( 0 < sizeOfActualPool )
24605 : {
24606 0 : SgMembershipOpStorageClass* storageArray = new SgMembershipOpStorageClass[sizeOfActualPool] ;
24607 0 : storageClassIndex = SgMembershipOp::initializeStorageClassArray (storageArray); ;
24608 0 : assert ( storageClassIndex == sizeOfActualPool );
24609 0 : out.write ( (char*) (storageArray) , sizeof ( SgMembershipOpStorageClass ) * sizeOfActualPool) ;
24610 0 : delete [] storageArray;
24611 0 : SgMembershipOpStorageClass :: writeEasyStorageDataToFile(out) ;
24612 : }
24613 :
24614 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMicrosoftAttributeDeclaration );
24615 3 : storageClassIndex = 0 ;
24616 3 : if ( 0 < sizeOfActualPool )
24617 : {
24618 0 : SgMicrosoftAttributeDeclarationStorageClass* storageArray = new SgMicrosoftAttributeDeclarationStorageClass[sizeOfActualPool] ;
24619 0 : storageClassIndex = SgMicrosoftAttributeDeclaration::initializeStorageClassArray (storageArray); ;
24620 0 : assert ( storageClassIndex == sizeOfActualPool );
24621 0 : out.write ( (char*) (storageArray) , sizeof ( SgMicrosoftAttributeDeclarationStorageClass ) * sizeOfActualPool) ;
24622 0 : delete [] storageArray;
24623 0 : SgMicrosoftAttributeDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
24624 : }
24625 :
24626 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMinusAssignOp );
24627 3 : storageClassIndex = 0 ;
24628 3 : if ( 0 < sizeOfActualPool )
24629 : {
24630 11 : SgMinusAssignOpStorageClass* storageArray = new SgMinusAssignOpStorageClass[sizeOfActualPool] ;
24631 1 : storageClassIndex = SgMinusAssignOp::initializeStorageClassArray (storageArray); ;
24632 1 : assert ( storageClassIndex == sizeOfActualPool );
24633 1 : out.write ( (char*) (storageArray) , sizeof ( SgMinusAssignOpStorageClass ) * sizeOfActualPool) ;
24634 1 : delete [] storageArray;
24635 1 : SgMinusAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24636 : }
24637 :
24638 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMinusMinusOp );
24639 3 : storageClassIndex = 0 ;
24640 3 : if ( 0 < sizeOfActualPool )
24641 : {
24642 49 : SgMinusMinusOpStorageClass* storageArray = new SgMinusMinusOpStorageClass[sizeOfActualPool] ;
24643 1 : storageClassIndex = SgMinusMinusOp::initializeStorageClassArray (storageArray); ;
24644 1 : assert ( storageClassIndex == sizeOfActualPool );
24645 1 : out.write ( (char*) (storageArray) , sizeof ( SgMinusMinusOpStorageClass ) * sizeOfActualPool) ;
24646 1 : delete [] storageArray;
24647 1 : SgMinusMinusOpStorageClass :: writeEasyStorageDataToFile(out) ;
24648 : }
24649 :
24650 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMinusOp );
24651 3 : storageClassIndex = 0 ;
24652 3 : if ( 0 < sizeOfActualPool )
24653 : {
24654 58 : SgMinusOpStorageClass* storageArray = new SgMinusOpStorageClass[sizeOfActualPool] ;
24655 1 : storageClassIndex = SgMinusOp::initializeStorageClassArray (storageArray); ;
24656 1 : assert ( storageClassIndex == sizeOfActualPool );
24657 1 : out.write ( (char*) (storageArray) , sizeof ( SgMinusOpStorageClass ) * sizeOfActualPool) ;
24658 1 : delete [] storageArray;
24659 1 : SgMinusOpStorageClass :: writeEasyStorageDataToFile(out) ;
24660 : }
24661 :
24662 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModAssignOp );
24663 3 : storageClassIndex = 0 ;
24664 3 : if ( 0 < sizeOfActualPool )
24665 : {
24666 0 : SgModAssignOpStorageClass* storageArray = new SgModAssignOpStorageClass[sizeOfActualPool] ;
24667 0 : storageClassIndex = SgModAssignOp::initializeStorageClassArray (storageArray); ;
24668 0 : assert ( storageClassIndex == sizeOfActualPool );
24669 0 : out.write ( (char*) (storageArray) , sizeof ( SgModAssignOpStorageClass ) * sizeOfActualPool) ;
24670 0 : delete [] storageArray;
24671 0 : SgModAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24672 : }
24673 :
24674 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModOp );
24675 3 : storageClassIndex = 0 ;
24676 3 : if ( 0 < sizeOfActualPool )
24677 : {
24678 6 : SgModOpStorageClass* storageArray = new SgModOpStorageClass[sizeOfActualPool] ;
24679 1 : storageClassIndex = SgModOp::initializeStorageClassArray (storageArray); ;
24680 1 : assert ( storageClassIndex == sizeOfActualPool );
24681 1 : out.write ( (char*) (storageArray) , sizeof ( SgModOpStorageClass ) * sizeOfActualPool) ;
24682 1 : delete [] storageArray;
24683 1 : SgModOpStorageClass :: writeEasyStorageDataToFile(out) ;
24684 : }
24685 :
24686 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModifier );
24687 3 : storageClassIndex = 0 ;
24688 3 : if ( 0 < sizeOfActualPool )
24689 : {
24690 0 : SgModifierStorageClass* storageArray = new SgModifierStorageClass[sizeOfActualPool] ;
24691 0 : storageClassIndex = SgModifier::initializeStorageClassArray (storageArray); ;
24692 0 : assert ( storageClassIndex == sizeOfActualPool );
24693 0 : out.write ( (char*) (storageArray) , sizeof ( SgModifierStorageClass ) * sizeOfActualPool) ;
24694 0 : delete [] storageArray;
24695 : }
24696 :
24697 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModifierNodes );
24698 3 : storageClassIndex = 0 ;
24699 3 : if ( 0 < sizeOfActualPool )
24700 : {
24701 0 : SgModifierNodesStorageClass* storageArray = new SgModifierNodesStorageClass[sizeOfActualPool] ;
24702 0 : storageClassIndex = SgModifierNodes::initializeStorageClassArray (storageArray); ;
24703 0 : assert ( storageClassIndex == sizeOfActualPool );
24704 0 : out.write ( (char*) (storageArray) , sizeof ( SgModifierNodesStorageClass ) * sizeOfActualPool) ;
24705 0 : delete [] storageArray;
24706 0 : SgModifierNodesStorageClass :: writeEasyStorageDataToFile(out) ;
24707 : }
24708 :
24709 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModifierType );
24710 3 : storageClassIndex = 0 ;
24711 3 : if ( 0 < sizeOfActualPool )
24712 : {
24713 878 : SgModifierTypeStorageClass* storageArray = new SgModifierTypeStorageClass[sizeOfActualPool] ;
24714 2 : storageClassIndex = SgModifierType::initializeStorageClassArray (storageArray); ;
24715 2 : assert ( storageClassIndex == sizeOfActualPool );
24716 2 : out.write ( (char*) (storageArray) , sizeof ( SgModifierTypeStorageClass ) * sizeOfActualPool) ;
24717 2 : delete [] storageArray;
24718 2 : SgModifierTypeStorageClass :: writeEasyStorageDataToFile(out) ;
24719 : }
24720 :
24721 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModuleStatement );
24722 3 : storageClassIndex = 0 ;
24723 3 : if ( 0 < sizeOfActualPool )
24724 : {
24725 0 : SgModuleStatementStorageClass* storageArray = new SgModuleStatementStorageClass[sizeOfActualPool] ;
24726 0 : storageClassIndex = SgModuleStatement::initializeStorageClassArray (storageArray); ;
24727 0 : assert ( storageClassIndex == sizeOfActualPool );
24728 0 : out.write ( (char*) (storageArray) , sizeof ( SgModuleStatementStorageClass ) * sizeOfActualPool) ;
24729 0 : delete [] storageArray;
24730 0 : SgModuleStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24731 : }
24732 :
24733 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgModuleSymbol );
24734 3 : storageClassIndex = 0 ;
24735 3 : if ( 0 < sizeOfActualPool )
24736 : {
24737 0 : SgModuleSymbolStorageClass* storageArray = new SgModuleSymbolStorageClass[sizeOfActualPool] ;
24738 0 : storageClassIndex = SgModuleSymbol::initializeStorageClassArray (storageArray); ;
24739 0 : assert ( storageClassIndex == sizeOfActualPool );
24740 0 : out.write ( (char*) (storageArray) , sizeof ( SgModuleSymbolStorageClass ) * sizeOfActualPool) ;
24741 0 : delete [] storageArray;
24742 0 : SgModuleSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24743 : }
24744 :
24745 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMultAssignOp );
24746 3 : storageClassIndex = 0 ;
24747 3 : if ( 0 < sizeOfActualPool )
24748 : {
24749 3 : SgMultAssignOpStorageClass* storageArray = new SgMultAssignOpStorageClass[sizeOfActualPool] ;
24750 1 : storageClassIndex = SgMultAssignOp::initializeStorageClassArray (storageArray); ;
24751 1 : assert ( storageClassIndex == sizeOfActualPool );
24752 1 : out.write ( (char*) (storageArray) , sizeof ( SgMultAssignOpStorageClass ) * sizeOfActualPool) ;
24753 1 : delete [] storageArray;
24754 1 : SgMultAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
24755 : }
24756 :
24757 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgMultiplyOp );
24758 3 : storageClassIndex = 0 ;
24759 3 : if ( 0 < sizeOfActualPool )
24760 : {
24761 67 : SgMultiplyOpStorageClass* storageArray = new SgMultiplyOpStorageClass[sizeOfActualPool] ;
24762 2 : storageClassIndex = SgMultiplyOp::initializeStorageClassArray (storageArray); ;
24763 2 : assert ( storageClassIndex == sizeOfActualPool );
24764 2 : out.write ( (char*) (storageArray) , sizeof ( SgMultiplyOpStorageClass ) * sizeOfActualPool) ;
24765 2 : delete [] storageArray;
24766 2 : SgMultiplyOpStorageClass :: writeEasyStorageDataToFile(out) ;
24767 : }
24768 :
24769 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgName );
24770 3 : storageClassIndex = 0 ;
24771 3 : if ( 0 < sizeOfActualPool )
24772 : {
24773 0 : SgNameStorageClass* storageArray = new SgNameStorageClass[sizeOfActualPool] ;
24774 0 : storageClassIndex = SgName::initializeStorageClassArray (storageArray); ;
24775 0 : assert ( storageClassIndex == sizeOfActualPool );
24776 0 : out.write ( (char*) (storageArray) , sizeof ( SgNameStorageClass ) * sizeOfActualPool) ;
24777 0 : delete [] storageArray;
24778 0 : SgNameStorageClass :: writeEasyStorageDataToFile(out) ;
24779 : }
24780 :
24781 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNameGroup );
24782 3 : storageClassIndex = 0 ;
24783 3 : if ( 0 < sizeOfActualPool )
24784 : {
24785 0 : SgNameGroupStorageClass* storageArray = new SgNameGroupStorageClass[sizeOfActualPool] ;
24786 0 : storageClassIndex = SgNameGroup::initializeStorageClassArray (storageArray); ;
24787 0 : assert ( storageClassIndex == sizeOfActualPool );
24788 0 : out.write ( (char*) (storageArray) , sizeof ( SgNameGroupStorageClass ) * sizeOfActualPool) ;
24789 0 : delete [] storageArray;
24790 0 : SgNameGroupStorageClass :: writeEasyStorageDataToFile(out) ;
24791 : }
24792 :
24793 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamedType );
24794 3 : storageClassIndex = 0 ;
24795 3 : if ( 0 < sizeOfActualPool )
24796 : {
24797 0 : SgNamedTypeStorageClass* storageArray = new SgNamedTypeStorageClass[sizeOfActualPool] ;
24798 0 : storageClassIndex = SgNamedType::initializeStorageClassArray (storageArray); ;
24799 0 : assert ( storageClassIndex == sizeOfActualPool );
24800 0 : out.write ( (char*) (storageArray) , sizeof ( SgNamedTypeStorageClass ) * sizeOfActualPool) ;
24801 0 : delete [] storageArray;
24802 0 : SgNamedTypeStorageClass :: writeEasyStorageDataToFile(out) ;
24803 : }
24804 :
24805 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamelistStatement );
24806 3 : storageClassIndex = 0 ;
24807 3 : if ( 0 < sizeOfActualPool )
24808 : {
24809 0 : SgNamelistStatementStorageClass* storageArray = new SgNamelistStatementStorageClass[sizeOfActualPool] ;
24810 0 : storageClassIndex = SgNamelistStatement::initializeStorageClassArray (storageArray); ;
24811 0 : assert ( storageClassIndex == sizeOfActualPool );
24812 0 : out.write ( (char*) (storageArray) , sizeof ( SgNamelistStatementStorageClass ) * sizeOfActualPool) ;
24813 0 : delete [] storageArray;
24814 0 : SgNamelistStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24815 : }
24816 :
24817 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamespaceAliasDeclarationStatement );
24818 3 : storageClassIndex = 0 ;
24819 3 : if ( 0 < sizeOfActualPool )
24820 : {
24821 0 : SgNamespaceAliasDeclarationStatementStorageClass* storageArray = new SgNamespaceAliasDeclarationStatementStorageClass[sizeOfActualPool] ;
24822 0 : storageClassIndex = SgNamespaceAliasDeclarationStatement::initializeStorageClassArray (storageArray); ;
24823 0 : assert ( storageClassIndex == sizeOfActualPool );
24824 0 : out.write ( (char*) (storageArray) , sizeof ( SgNamespaceAliasDeclarationStatementStorageClass ) * sizeOfActualPool) ;
24825 0 : delete [] storageArray;
24826 0 : SgNamespaceAliasDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24827 : }
24828 :
24829 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamespaceDeclarationStatement );
24830 3 : storageClassIndex = 0 ;
24831 3 : if ( 0 < sizeOfActualPool )
24832 : {
24833 122 : SgNamespaceDeclarationStatementStorageClass* storageArray = new SgNamespaceDeclarationStatementStorageClass[sizeOfActualPool] ;
24834 1 : storageClassIndex = SgNamespaceDeclarationStatement::initializeStorageClassArray (storageArray); ;
24835 1 : assert ( storageClassIndex == sizeOfActualPool );
24836 1 : out.write ( (char*) (storageArray) , sizeof ( SgNamespaceDeclarationStatementStorageClass ) * sizeOfActualPool) ;
24837 1 : delete [] storageArray;
24838 1 : SgNamespaceDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24839 : }
24840 :
24841 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamespaceDefinitionStatement );
24842 3 : storageClassIndex = 0 ;
24843 3 : if ( 0 < sizeOfActualPool )
24844 : {
24845 136 : SgNamespaceDefinitionStatementStorageClass* storageArray = new SgNamespaceDefinitionStatementStorageClass[sizeOfActualPool] ;
24846 1 : storageClassIndex = SgNamespaceDefinitionStatement::initializeStorageClassArray (storageArray); ;
24847 1 : assert ( storageClassIndex == sizeOfActualPool );
24848 1 : out.write ( (char*) (storageArray) , sizeof ( SgNamespaceDefinitionStatementStorageClass ) * sizeOfActualPool) ;
24849 1 : delete [] storageArray;
24850 1 : SgNamespaceDefinitionStatementStorageClass :: writeEasyStorageDataToFile(out) ;
24851 : }
24852 :
24853 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNamespaceSymbol );
24854 3 : storageClassIndex = 0 ;
24855 3 : if ( 0 < sizeOfActualPool )
24856 : {
24857 15 : SgNamespaceSymbolStorageClass* storageArray = new SgNamespaceSymbolStorageClass[sizeOfActualPool] ;
24858 1 : storageClassIndex = SgNamespaceSymbol::initializeStorageClassArray (storageArray); ;
24859 1 : assert ( storageClassIndex == sizeOfActualPool );
24860 1 : out.write ( (char*) (storageArray) , sizeof ( SgNamespaceSymbolStorageClass ) * sizeOfActualPool) ;
24861 1 : delete [] storageArray;
24862 1 : SgNamespaceSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
24863 : }
24864 :
24865 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNaryOp );
24866 3 : storageClassIndex = 0 ;
24867 3 : if ( 0 < sizeOfActualPool )
24868 : {
24869 0 : SgNaryOpStorageClass* storageArray = new SgNaryOpStorageClass[sizeOfActualPool] ;
24870 0 : storageClassIndex = SgNaryOp::initializeStorageClassArray (storageArray); ;
24871 0 : assert ( storageClassIndex == sizeOfActualPool );
24872 0 : out.write ( (char*) (storageArray) , sizeof ( SgNaryOpStorageClass ) * sizeOfActualPool) ;
24873 0 : delete [] storageArray;
24874 0 : SgNaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
24875 : }
24876 :
24877 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNaryBooleanOp );
24878 3 : storageClassIndex = 0 ;
24879 3 : if ( 0 < sizeOfActualPool )
24880 : {
24881 0 : SgNaryBooleanOpStorageClass* storageArray = new SgNaryBooleanOpStorageClass[sizeOfActualPool] ;
24882 0 : storageClassIndex = SgNaryBooleanOp::initializeStorageClassArray (storageArray); ;
24883 0 : assert ( storageClassIndex == sizeOfActualPool );
24884 0 : out.write ( (char*) (storageArray) , sizeof ( SgNaryBooleanOpStorageClass ) * sizeOfActualPool) ;
24885 0 : delete [] storageArray;
24886 0 : SgNaryBooleanOpStorageClass :: writeEasyStorageDataToFile(out) ;
24887 : }
24888 :
24889 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNaryComparisonOp );
24890 3 : storageClassIndex = 0 ;
24891 3 : if ( 0 < sizeOfActualPool )
24892 : {
24893 0 : SgNaryComparisonOpStorageClass* storageArray = new SgNaryComparisonOpStorageClass[sizeOfActualPool] ;
24894 0 : storageClassIndex = SgNaryComparisonOp::initializeStorageClassArray (storageArray); ;
24895 0 : assert ( storageClassIndex == sizeOfActualPool );
24896 0 : out.write ( (char*) (storageArray) , sizeof ( SgNaryComparisonOpStorageClass ) * sizeOfActualPool) ;
24897 0 : delete [] storageArray;
24898 0 : SgNaryComparisonOpStorageClass :: writeEasyStorageDataToFile(out) ;
24899 : }
24900 :
24901 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNewExp );
24902 3 : storageClassIndex = 0 ;
24903 3 : if ( 0 < sizeOfActualPool )
24904 : {
24905 15 : SgNewExpStorageClass* storageArray = new SgNewExpStorageClass[sizeOfActualPool] ;
24906 1 : storageClassIndex = SgNewExp::initializeStorageClassArray (storageArray); ;
24907 1 : assert ( storageClassIndex == sizeOfActualPool );
24908 1 : out.write ( (char*) (storageArray) , sizeof ( SgNewExpStorageClass ) * sizeOfActualPool) ;
24909 1 : delete [] storageArray;
24910 1 : SgNewExpStorageClass :: writeEasyStorageDataToFile(out) ;
24911 : }
24912 :
24913 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNode );
24914 3 : storageClassIndex = 0 ;
24915 3 : if ( 0 < sizeOfActualPool )
24916 : {
24917 0 : SgNodeStorageClass* storageArray = new SgNodeStorageClass[sizeOfActualPool] ;
24918 0 : storageClassIndex = SgNode::initializeStorageClassArray (storageArray); ;
24919 0 : assert ( storageClassIndex == sizeOfActualPool );
24920 0 : out.write ( (char*) (storageArray) , sizeof ( SgNodeStorageClass ) * sizeOfActualPool) ;
24921 0 : delete [] storageArray;
24922 : }
24923 :
24924 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNoexceptOp );
24925 3 : storageClassIndex = 0 ;
24926 3 : if ( 0 < sizeOfActualPool )
24927 : {
24928 19 : SgNoexceptOpStorageClass* storageArray = new SgNoexceptOpStorageClass[sizeOfActualPool] ;
24929 1 : storageClassIndex = SgNoexceptOp::initializeStorageClassArray (storageArray); ;
24930 1 : assert ( storageClassIndex == sizeOfActualPool );
24931 1 : out.write ( (char*) (storageArray) , sizeof ( SgNoexceptOpStorageClass ) * sizeOfActualPool) ;
24932 1 : delete [] storageArray;
24933 1 : SgNoexceptOpStorageClass :: writeEasyStorageDataToFile(out) ;
24934 : }
24935 :
24936 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNotEqualOp );
24937 3 : storageClassIndex = 0 ;
24938 3 : if ( 0 < sizeOfActualPool )
24939 : {
24940 96 : SgNotEqualOpStorageClass* storageArray = new SgNotEqualOpStorageClass[sizeOfActualPool] ;
24941 1 : storageClassIndex = SgNotEqualOp::initializeStorageClassArray (storageArray); ;
24942 1 : assert ( storageClassIndex == sizeOfActualPool );
24943 1 : out.write ( (char*) (storageArray) , sizeof ( SgNotEqualOpStorageClass ) * sizeOfActualPool) ;
24944 1 : delete [] storageArray;
24945 1 : SgNotEqualOpStorageClass :: writeEasyStorageDataToFile(out) ;
24946 : }
24947 :
24948 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNotOp );
24949 3 : storageClassIndex = 0 ;
24950 3 : if ( 0 < sizeOfActualPool )
24951 : {
24952 221 : SgNotOpStorageClass* storageArray = new SgNotOpStorageClass[sizeOfActualPool] ;
24953 1 : storageClassIndex = SgNotOp::initializeStorageClassArray (storageArray); ;
24954 1 : assert ( storageClassIndex == sizeOfActualPool );
24955 1 : out.write ( (char*) (storageArray) , sizeof ( SgNotOpStorageClass ) * sizeOfActualPool) ;
24956 1 : delete [] storageArray;
24957 1 : SgNotOpStorageClass :: writeEasyStorageDataToFile(out) ;
24958 : }
24959 :
24960 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonMembershipOp );
24961 3 : storageClassIndex = 0 ;
24962 3 : if ( 0 < sizeOfActualPool )
24963 : {
24964 0 : SgNonMembershipOpStorageClass* storageArray = new SgNonMembershipOpStorageClass[sizeOfActualPool] ;
24965 0 : storageClassIndex = SgNonMembershipOp::initializeStorageClassArray (storageArray); ;
24966 0 : assert ( storageClassIndex == sizeOfActualPool );
24967 0 : out.write ( (char*) (storageArray) , sizeof ( SgNonMembershipOpStorageClass ) * sizeOfActualPool) ;
24968 0 : delete [] storageArray;
24969 0 : SgNonMembershipOpStorageClass :: writeEasyStorageDataToFile(out) ;
24970 : }
24971 :
24972 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonrealDecl );
24973 3 : storageClassIndex = 0 ;
24974 3 : if ( 0 < sizeOfActualPool )
24975 : {
24976 5081 : SgNonrealDeclStorageClass* storageArray = new SgNonrealDeclStorageClass[sizeOfActualPool] ;
24977 1 : storageClassIndex = SgNonrealDecl::initializeStorageClassArray (storageArray); ;
24978 1 : assert ( storageClassIndex == sizeOfActualPool );
24979 1 : out.write ( (char*) (storageArray) , sizeof ( SgNonrealDeclStorageClass ) * sizeOfActualPool) ;
24980 1 : delete [] storageArray;
24981 1 : SgNonrealDeclStorageClass :: writeEasyStorageDataToFile(out) ;
24982 : }
24983 :
24984 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonrealRefExp );
24985 3 : storageClassIndex = 0 ;
24986 3 : if ( 0 < sizeOfActualPool )
24987 : {
24988 1495 : SgNonrealRefExpStorageClass* storageArray = new SgNonrealRefExpStorageClass[sizeOfActualPool] ;
24989 1 : storageClassIndex = SgNonrealRefExp::initializeStorageClassArray (storageArray); ;
24990 1 : assert ( storageClassIndex == sizeOfActualPool );
24991 1 : out.write ( (char*) (storageArray) , sizeof ( SgNonrealRefExpStorageClass ) * sizeOfActualPool) ;
24992 1 : delete [] storageArray;
24993 1 : SgNonrealRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
24994 : }
24995 :
24996 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonrealSymbol );
24997 3 : storageClassIndex = 0 ;
24998 3 : if ( 0 < sizeOfActualPool )
24999 : {
25000 5081 : SgNonrealSymbolStorageClass* storageArray = new SgNonrealSymbolStorageClass[sizeOfActualPool] ;
25001 1 : storageClassIndex = SgNonrealSymbol::initializeStorageClassArray (storageArray); ;
25002 1 : assert ( storageClassIndex == sizeOfActualPool );
25003 1 : out.write ( (char*) (storageArray) , sizeof ( SgNonrealSymbolStorageClass ) * sizeOfActualPool) ;
25004 1 : delete [] storageArray;
25005 1 : SgNonrealSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
25006 : }
25007 :
25008 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonrealType );
25009 3 : storageClassIndex = 0 ;
25010 3 : if ( 0 < sizeOfActualPool )
25011 : {
25012 5081 : SgNonrealTypeStorageClass* storageArray = new SgNonrealTypeStorageClass[sizeOfActualPool] ;
25013 1 : storageClassIndex = SgNonrealType::initializeStorageClassArray (storageArray); ;
25014 1 : assert ( storageClassIndex == sizeOfActualPool );
25015 1 : out.write ( (char*) (storageArray) , sizeof ( SgNonrealTypeStorageClass ) * sizeOfActualPool) ;
25016 1 : delete [] storageArray;
25017 1 : SgNonrealTypeStorageClass :: writeEasyStorageDataToFile(out) ;
25018 : }
25019 :
25020 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNonrealBaseClass );
25021 3 : storageClassIndex = 0 ;
25022 3 : if ( 0 < sizeOfActualPool )
25023 : {
25024 1 : SgNonrealBaseClassStorageClass* storageArray = new SgNonrealBaseClassStorageClass[sizeOfActualPool] ;
25025 1 : storageClassIndex = SgNonrealBaseClass::initializeStorageClassArray (storageArray); ;
25026 1 : assert ( storageClassIndex == sizeOfActualPool );
25027 1 : out.write ( (char*) (storageArray) , sizeof ( SgNonrealBaseClassStorageClass ) * sizeOfActualPool) ;
25028 1 : delete [] storageArray;
25029 : }
25030 :
25031 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNullExpression );
25032 3 : storageClassIndex = 0 ;
25033 3 : if ( 0 < sizeOfActualPool )
25034 : {
25035 123 : SgNullExpressionStorageClass* storageArray = new SgNullExpressionStorageClass[sizeOfActualPool] ;
25036 2 : storageClassIndex = SgNullExpression::initializeStorageClassArray (storageArray); ;
25037 2 : assert ( storageClassIndex == sizeOfActualPool );
25038 2 : out.write ( (char*) (storageArray) , sizeof ( SgNullExpressionStorageClass ) * sizeOfActualPool) ;
25039 2 : delete [] storageArray;
25040 2 : SgNullExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
25041 : }
25042 :
25043 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNullptrValExp );
25044 3 : storageClassIndex = 0 ;
25045 3 : if ( 0 < sizeOfActualPool )
25046 : {
25047 7 : SgNullptrValExpStorageClass* storageArray = new SgNullptrValExpStorageClass[sizeOfActualPool] ;
25048 1 : storageClassIndex = SgNullptrValExp::initializeStorageClassArray (storageArray); ;
25049 1 : assert ( storageClassIndex == sizeOfActualPool );
25050 1 : out.write ( (char*) (storageArray) , sizeof ( SgNullptrValExpStorageClass ) * sizeOfActualPool) ;
25051 1 : delete [] storageArray;
25052 1 : SgNullptrValExpStorageClass :: writeEasyStorageDataToFile(out) ;
25053 : }
25054 :
25055 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNullStatement );
25056 3 : storageClassIndex = 0 ;
25057 3 : if ( 0 < sizeOfActualPool )
25058 : {
25059 21 : SgNullStatementStorageClass* storageArray = new SgNullStatementStorageClass[sizeOfActualPool] ;
25060 1 : storageClassIndex = SgNullStatement::initializeStorageClassArray (storageArray); ;
25061 1 : assert ( storageClassIndex == sizeOfActualPool );
25062 1 : out.write ( (char*) (storageArray) , sizeof ( SgNullStatementStorageClass ) * sizeOfActualPool) ;
25063 1 : delete [] storageArray;
25064 1 : SgNullStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25065 : }
25066 :
25067 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgNullifyStatement );
25068 3 : storageClassIndex = 0 ;
25069 3 : if ( 0 < sizeOfActualPool )
25070 : {
25071 0 : SgNullifyStatementStorageClass* storageArray = new SgNullifyStatementStorageClass[sizeOfActualPool] ;
25072 0 : storageClassIndex = SgNullifyStatement::initializeStorageClassArray (storageArray); ;
25073 0 : assert ( storageClassIndex == sizeOfActualPool );
25074 0 : out.write ( (char*) (storageArray) , sizeof ( SgNullifyStatementStorageClass ) * sizeOfActualPool) ;
25075 0 : delete [] storageArray;
25076 0 : SgNullifyStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25077 : }
25078 :
25079 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAtomicStatement );
25080 3 : storageClassIndex = 0 ;
25081 3 : if ( 0 < sizeOfActualPool )
25082 : {
25083 0 : SgOmpAtomicStatementStorageClass* storageArray = new SgOmpAtomicStatementStorageClass[sizeOfActualPool] ;
25084 0 : storageClassIndex = SgOmpAtomicStatement::initializeStorageClassArray (storageArray); ;
25085 0 : assert ( storageClassIndex == sizeOfActualPool );
25086 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAtomicStatementStorageClass ) * sizeOfActualPool) ;
25087 0 : delete [] storageArray;
25088 0 : SgOmpAtomicStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25089 : }
25090 :
25091 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpBarrierStatement );
25092 3 : storageClassIndex = 0 ;
25093 3 : if ( 0 < sizeOfActualPool )
25094 : {
25095 0 : SgOmpBarrierStatementStorageClass* storageArray = new SgOmpBarrierStatementStorageClass[sizeOfActualPool] ;
25096 0 : storageClassIndex = SgOmpBarrierStatement::initializeStorageClassArray (storageArray); ;
25097 0 : assert ( storageClassIndex == sizeOfActualPool );
25098 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpBarrierStatementStorageClass ) * sizeOfActualPool) ;
25099 0 : delete [] storageArray;
25100 0 : SgOmpBarrierStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25101 : }
25102 :
25103 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCriticalStatement );
25104 3 : storageClassIndex = 0 ;
25105 3 : if ( 0 < sizeOfActualPool )
25106 : {
25107 0 : SgOmpCriticalStatementStorageClass* storageArray = new SgOmpCriticalStatementStorageClass[sizeOfActualPool] ;
25108 0 : storageClassIndex = SgOmpCriticalStatement::initializeStorageClassArray (storageArray); ;
25109 0 : assert ( storageClassIndex == sizeOfActualPool );
25110 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCriticalStatementStorageClass ) * sizeOfActualPool) ;
25111 0 : delete [] storageArray;
25112 0 : SgOmpCriticalStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25113 : }
25114 :
25115 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirFieldBodyStatement );
25116 3 : storageClassIndex = 0 ;
25117 3 : if ( 0 < sizeOfActualPool )
25118 : {
25119 0 : SgUpirFieldBodyStatementStorageClass* storageArray = new SgUpirFieldBodyStatementStorageClass[sizeOfActualPool] ;
25120 0 : storageClassIndex = SgUpirFieldBodyStatement::initializeStorageClassArray (storageArray); ;
25121 0 : assert ( storageClassIndex == sizeOfActualPool );
25122 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirFieldBodyStatementStorageClass ) * sizeOfActualPool) ;
25123 0 : delete [] storageArray;
25124 0 : SgUpirFieldBodyStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25125 : }
25126 :
25127 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirBodyStatement );
25128 3 : storageClassIndex = 0 ;
25129 3 : if ( 0 < sizeOfActualPool )
25130 : {
25131 0 : SgUpirBodyStatementStorageClass* storageArray = new SgUpirBodyStatementStorageClass[sizeOfActualPool] ;
25132 0 : storageClassIndex = SgUpirBodyStatement::initializeStorageClassArray (storageArray); ;
25133 0 : assert ( storageClassIndex == sizeOfActualPool );
25134 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirBodyStatementStorageClass ) * sizeOfActualPool) ;
25135 0 : delete [] storageArray;
25136 0 : SgUpirBodyStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25137 : }
25138 :
25139 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirFieldStatement );
25140 3 : storageClassIndex = 0 ;
25141 3 : if ( 0 < sizeOfActualPool )
25142 : {
25143 0 : SgUpirFieldStatementStorageClass* storageArray = new SgUpirFieldStatementStorageClass[sizeOfActualPool] ;
25144 0 : storageClassIndex = SgUpirFieldStatement::initializeStorageClassArray (storageArray); ;
25145 0 : assert ( storageClassIndex == sizeOfActualPool );
25146 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirFieldStatementStorageClass ) * sizeOfActualPool) ;
25147 0 : delete [] storageArray;
25148 0 : SgUpirFieldStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25149 : }
25150 :
25151 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDoStatement );
25152 3 : storageClassIndex = 0 ;
25153 3 : if ( 0 < sizeOfActualPool )
25154 : {
25155 0 : SgOmpDoStatementStorageClass* storageArray = new SgOmpDoStatementStorageClass[sizeOfActualPool] ;
25156 0 : storageClassIndex = SgOmpDoStatement::initializeStorageClassArray (storageArray); ;
25157 0 : assert ( storageClassIndex == sizeOfActualPool );
25158 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDoStatementStorageClass ) * sizeOfActualPool) ;
25159 0 : delete [] storageArray;
25160 0 : SgOmpDoStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25161 : }
25162 :
25163 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpFlushStatement );
25164 3 : storageClassIndex = 0 ;
25165 3 : if ( 0 < sizeOfActualPool )
25166 : {
25167 0 : SgOmpFlushStatementStorageClass* storageArray = new SgOmpFlushStatementStorageClass[sizeOfActualPool] ;
25168 0 : storageClassIndex = SgOmpFlushStatement::initializeStorageClassArray (storageArray); ;
25169 0 : assert ( storageClassIndex == sizeOfActualPool );
25170 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpFlushStatementStorageClass ) * sizeOfActualPool) ;
25171 0 : delete [] storageArray;
25172 0 : SgOmpFlushStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25173 : }
25174 :
25175 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAllocateStatement );
25176 3 : storageClassIndex = 0 ;
25177 3 : if ( 0 < sizeOfActualPool )
25178 : {
25179 0 : SgOmpAllocateStatementStorageClass* storageArray = new SgOmpAllocateStatementStorageClass[sizeOfActualPool] ;
25180 0 : storageClassIndex = SgOmpAllocateStatement::initializeStorageClassArray (storageArray); ;
25181 0 : assert ( storageClassIndex == sizeOfActualPool );
25182 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAllocateStatementStorageClass ) * sizeOfActualPool) ;
25183 0 : delete [] storageArray;
25184 0 : SgOmpAllocateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25185 : }
25186 :
25187 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDeclareSimdStatement );
25188 3 : storageClassIndex = 0 ;
25189 3 : if ( 0 < sizeOfActualPool )
25190 : {
25191 0 : SgOmpDeclareSimdStatementStorageClass* storageArray = new SgOmpDeclareSimdStatementStorageClass[sizeOfActualPool] ;
25192 0 : storageClassIndex = SgOmpDeclareSimdStatement::initializeStorageClassArray (storageArray); ;
25193 0 : assert ( storageClassIndex == sizeOfActualPool );
25194 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDeclareSimdStatementStorageClass ) * sizeOfActualPool) ;
25195 0 : delete [] storageArray;
25196 0 : SgOmpDeclareSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25197 : }
25198 :
25199 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirWorksharingStatement );
25200 3 : storageClassIndex = 0 ;
25201 3 : if ( 0 < sizeOfActualPool )
25202 : {
25203 0 : SgUpirWorksharingStatementStorageClass* storageArray = new SgUpirWorksharingStatementStorageClass[sizeOfActualPool] ;
25204 0 : storageClassIndex = SgUpirWorksharingStatement::initializeStorageClassArray (storageArray); ;
25205 0 : assert ( storageClassIndex == sizeOfActualPool );
25206 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirWorksharingStatementStorageClass ) * sizeOfActualPool) ;
25207 0 : delete [] storageArray;
25208 0 : SgUpirWorksharingStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25209 : }
25210 :
25211 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpForSimdStatement );
25212 3 : storageClassIndex = 0 ;
25213 3 : if ( 0 < sizeOfActualPool )
25214 : {
25215 0 : SgOmpForSimdStatementStorageClass* storageArray = new SgOmpForSimdStatementStorageClass[sizeOfActualPool] ;
25216 0 : storageClassIndex = SgOmpForSimdStatement::initializeStorageClassArray (storageArray); ;
25217 0 : assert ( storageClassIndex == sizeOfActualPool );
25218 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpForSimdStatementStorageClass ) * sizeOfActualPool) ;
25219 0 : delete [] storageArray;
25220 0 : SgOmpForSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25221 : }
25222 :
25223 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMasterStatement );
25224 3 : storageClassIndex = 0 ;
25225 3 : if ( 0 < sizeOfActualPool )
25226 : {
25227 0 : SgOmpMasterStatementStorageClass* storageArray = new SgOmpMasterStatementStorageClass[sizeOfActualPool] ;
25228 0 : storageClassIndex = SgOmpMasterStatement::initializeStorageClassArray (storageArray); ;
25229 0 : assert ( storageClassIndex == sizeOfActualPool );
25230 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMasterStatementStorageClass ) * sizeOfActualPool) ;
25231 0 : delete [] storageArray;
25232 0 : SgOmpMasterStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25233 : }
25234 :
25235 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskyieldStatement );
25236 3 : storageClassIndex = 0 ;
25237 3 : if ( 0 < sizeOfActualPool )
25238 : {
25239 0 : SgOmpTaskyieldStatementStorageClass* storageArray = new SgOmpTaskyieldStatementStorageClass[sizeOfActualPool] ;
25240 0 : storageClassIndex = SgOmpTaskyieldStatement::initializeStorageClassArray (storageArray); ;
25241 0 : assert ( storageClassIndex == sizeOfActualPool );
25242 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskyieldStatementStorageClass ) * sizeOfActualPool) ;
25243 0 : delete [] storageArray;
25244 0 : SgOmpTaskyieldStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25245 : }
25246 :
25247 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMetadirectiveStatement );
25248 3 : storageClassIndex = 0 ;
25249 3 : if ( 0 < sizeOfActualPool )
25250 : {
25251 0 : SgOmpMetadirectiveStatementStorageClass* storageArray = new SgOmpMetadirectiveStatementStorageClass[sizeOfActualPool] ;
25252 0 : storageClassIndex = SgOmpMetadirectiveStatement::initializeStorageClassArray (storageArray); ;
25253 0 : assert ( storageClassIndex == sizeOfActualPool );
25254 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMetadirectiveStatementStorageClass ) * sizeOfActualPool) ;
25255 0 : delete [] storageArray;
25256 0 : SgOmpMetadirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25257 : }
25258 :
25259 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpOrderedStatement );
25260 3 : storageClassIndex = 0 ;
25261 3 : if ( 0 < sizeOfActualPool )
25262 : {
25263 0 : SgOmpOrderedStatementStorageClass* storageArray = new SgOmpOrderedStatementStorageClass[sizeOfActualPool] ;
25264 0 : storageClassIndex = SgOmpOrderedStatement::initializeStorageClassArray (storageArray); ;
25265 0 : assert ( storageClassIndex == sizeOfActualPool );
25266 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpOrderedStatementStorageClass ) * sizeOfActualPool) ;
25267 0 : delete [] storageArray;
25268 0 : SgOmpOrderedStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25269 : }
25270 :
25271 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpOrderedDependStatement );
25272 3 : storageClassIndex = 0 ;
25273 3 : if ( 0 < sizeOfActualPool )
25274 : {
25275 0 : SgOmpOrderedDependStatementStorageClass* storageArray = new SgOmpOrderedDependStatementStorageClass[sizeOfActualPool] ;
25276 0 : storageClassIndex = SgOmpOrderedDependStatement::initializeStorageClassArray (storageArray); ;
25277 0 : assert ( storageClassIndex == sizeOfActualPool );
25278 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpOrderedDependStatementStorageClass ) * sizeOfActualPool) ;
25279 0 : delete [] storageArray;
25280 0 : SgOmpOrderedDependStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25281 : }
25282 :
25283 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirSpmdStatement );
25284 3 : storageClassIndex = 0 ;
25285 3 : if ( 0 < sizeOfActualPool )
25286 : {
25287 0 : SgUpirSpmdStatementStorageClass* storageArray = new SgUpirSpmdStatementStorageClass[sizeOfActualPool] ;
25288 0 : storageClassIndex = SgUpirSpmdStatement::initializeStorageClassArray (storageArray); ;
25289 0 : assert ( storageClassIndex == sizeOfActualPool );
25290 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirSpmdStatementStorageClass ) * sizeOfActualPool) ;
25291 0 : delete [] storageArray;
25292 0 : SgUpirSpmdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25293 : }
25294 :
25295 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsStatement );
25296 3 : storageClassIndex = 0 ;
25297 3 : if ( 0 < sizeOfActualPool )
25298 : {
25299 0 : SgOmpTeamsStatementStorageClass* storageArray = new SgOmpTeamsStatementStorageClass[sizeOfActualPool] ;
25300 0 : storageClassIndex = SgOmpTeamsStatement::initializeStorageClassArray (storageArray); ;
25301 0 : assert ( storageClassIndex == sizeOfActualPool );
25302 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsStatementStorageClass ) * sizeOfActualPool) ;
25303 0 : delete [] storageArray;
25304 0 : SgOmpTeamsStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25305 : }
25306 :
25307 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCancellationPointStatement );
25308 3 : storageClassIndex = 0 ;
25309 3 : if ( 0 < sizeOfActualPool )
25310 : {
25311 0 : SgOmpCancellationPointStatementStorageClass* storageArray = new SgOmpCancellationPointStatementStorageClass[sizeOfActualPool] ;
25312 0 : storageClassIndex = SgOmpCancellationPointStatement::initializeStorageClassArray (storageArray); ;
25313 0 : assert ( storageClassIndex == sizeOfActualPool );
25314 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCancellationPointStatementStorageClass ) * sizeOfActualPool) ;
25315 0 : delete [] storageArray;
25316 0 : SgOmpCancellationPointStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25317 : }
25318 :
25319 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDeclareMapperStatement );
25320 3 : storageClassIndex = 0 ;
25321 3 : if ( 0 < sizeOfActualPool )
25322 : {
25323 0 : SgOmpDeclareMapperStatementStorageClass* storageArray = new SgOmpDeclareMapperStatementStorageClass[sizeOfActualPool] ;
25324 0 : storageClassIndex = SgOmpDeclareMapperStatement::initializeStorageClassArray (storageArray); ;
25325 0 : assert ( storageClassIndex == sizeOfActualPool );
25326 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDeclareMapperStatementStorageClass ) * sizeOfActualPool) ;
25327 0 : delete [] storageArray;
25328 0 : SgOmpDeclareMapperStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25329 : }
25330 :
25331 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCancelStatement );
25332 3 : storageClassIndex = 0 ;
25333 3 : if ( 0 < sizeOfActualPool )
25334 : {
25335 0 : SgOmpCancelStatementStorageClass* storageArray = new SgOmpCancelStatementStorageClass[sizeOfActualPool] ;
25336 0 : storageClassIndex = SgOmpCancelStatement::initializeStorageClassArray (storageArray); ;
25337 0 : assert ( storageClassIndex == sizeOfActualPool );
25338 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCancelStatementStorageClass ) * sizeOfActualPool) ;
25339 0 : delete [] storageArray;
25340 0 : SgOmpCancelStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25341 : }
25342 :
25343 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskgroupStatement );
25344 3 : storageClassIndex = 0 ;
25345 3 : if ( 0 < sizeOfActualPool )
25346 : {
25347 0 : SgOmpTaskgroupStatementStorageClass* storageArray = new SgOmpTaskgroupStatementStorageClass[sizeOfActualPool] ;
25348 0 : storageClassIndex = SgOmpTaskgroupStatement::initializeStorageClassArray (storageArray); ;
25349 0 : assert ( storageClassIndex == sizeOfActualPool );
25350 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskgroupStatementStorageClass ) * sizeOfActualPool) ;
25351 0 : delete [] storageArray;
25352 0 : SgOmpTaskgroupStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25353 : }
25354 :
25355 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDepobjStatement );
25356 3 : storageClassIndex = 0 ;
25357 3 : if ( 0 < sizeOfActualPool )
25358 : {
25359 0 : SgOmpDepobjStatementStorageClass* storageArray = new SgOmpDepobjStatementStorageClass[sizeOfActualPool] ;
25360 0 : storageClassIndex = SgOmpDepobjStatement::initializeStorageClassArray (storageArray); ;
25361 0 : assert ( storageClassIndex == sizeOfActualPool );
25362 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDepobjStatementStorageClass ) * sizeOfActualPool) ;
25363 0 : delete [] storageArray;
25364 0 : SgOmpDepobjStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25365 : }
25366 :
25367 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDistributeStatement );
25368 3 : storageClassIndex = 0 ;
25369 3 : if ( 0 < sizeOfActualPool )
25370 : {
25371 0 : SgOmpDistributeStatementStorageClass* storageArray = new SgOmpDistributeStatementStorageClass[sizeOfActualPool] ;
25372 0 : storageClassIndex = SgOmpDistributeStatement::initializeStorageClassArray (storageArray); ;
25373 0 : assert ( storageClassIndex == sizeOfActualPool );
25374 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDistributeStatementStorageClass ) * sizeOfActualPool) ;
25375 0 : delete [] storageArray;
25376 0 : SgOmpDistributeStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25377 : }
25378 :
25379 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpLoopStatement );
25380 3 : storageClassIndex = 0 ;
25381 3 : if ( 0 < sizeOfActualPool )
25382 : {
25383 0 : SgOmpLoopStatementStorageClass* storageArray = new SgOmpLoopStatementStorageClass[sizeOfActualPool] ;
25384 0 : storageClassIndex = SgOmpLoopStatement::initializeStorageClassArray (storageArray); ;
25385 0 : assert ( storageClassIndex == sizeOfActualPool );
25386 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpLoopStatementStorageClass ) * sizeOfActualPool) ;
25387 0 : delete [] storageArray;
25388 0 : SgOmpLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25389 : }
25390 :
25391 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpScanStatement );
25392 3 : storageClassIndex = 0 ;
25393 3 : if ( 0 < sizeOfActualPool )
25394 : {
25395 0 : SgOmpScanStatementStorageClass* storageArray = new SgOmpScanStatementStorageClass[sizeOfActualPool] ;
25396 0 : storageClassIndex = SgOmpScanStatement::initializeStorageClassArray (storageArray); ;
25397 0 : assert ( storageClassIndex == sizeOfActualPool );
25398 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpScanStatementStorageClass ) * sizeOfActualPool) ;
25399 0 : delete [] storageArray;
25400 0 : SgOmpScanStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25401 : }
25402 :
25403 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskloopStatement );
25404 3 : storageClassIndex = 0 ;
25405 3 : if ( 0 < sizeOfActualPool )
25406 : {
25407 0 : SgOmpTaskloopStatementStorageClass* storageArray = new SgOmpTaskloopStatementStorageClass[sizeOfActualPool] ;
25408 0 : storageClassIndex = SgOmpTaskloopStatement::initializeStorageClassArray (storageArray); ;
25409 0 : assert ( storageClassIndex == sizeOfActualPool );
25410 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskloopStatementStorageClass ) * sizeOfActualPool) ;
25411 0 : delete [] storageArray;
25412 0 : SgOmpTaskloopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25413 : }
25414 :
25415 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetEnterDataStatement );
25416 3 : storageClassIndex = 0 ;
25417 3 : if ( 0 < sizeOfActualPool )
25418 : {
25419 0 : SgOmpTargetEnterDataStatementStorageClass* storageArray = new SgOmpTargetEnterDataStatementStorageClass[sizeOfActualPool] ;
25420 0 : storageClassIndex = SgOmpTargetEnterDataStatement::initializeStorageClassArray (storageArray); ;
25421 0 : assert ( storageClassIndex == sizeOfActualPool );
25422 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetEnterDataStatementStorageClass ) * sizeOfActualPool) ;
25423 0 : delete [] storageArray;
25424 0 : SgOmpTargetEnterDataStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25425 : }
25426 :
25427 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetExitDataStatement );
25428 3 : storageClassIndex = 0 ;
25429 3 : if ( 0 < sizeOfActualPool )
25430 : {
25431 0 : SgOmpTargetExitDataStatementStorageClass* storageArray = new SgOmpTargetExitDataStatementStorageClass[sizeOfActualPool] ;
25432 0 : storageClassIndex = SgOmpTargetExitDataStatement::initializeStorageClassArray (storageArray); ;
25433 0 : assert ( storageClassIndex == sizeOfActualPool );
25434 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetExitDataStatementStorageClass ) * sizeOfActualPool) ;
25435 0 : delete [] storageArray;
25436 0 : SgOmpTargetExitDataStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25437 : }
25438 :
25439 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSectionStatement );
25440 3 : storageClassIndex = 0 ;
25441 3 : if ( 0 < sizeOfActualPool )
25442 : {
25443 0 : SgOmpSectionStatementStorageClass* storageArray = new SgOmpSectionStatementStorageClass[sizeOfActualPool] ;
25444 0 : storageClassIndex = SgOmpSectionStatement::initializeStorageClassArray (storageArray); ;
25445 0 : assert ( storageClassIndex == sizeOfActualPool );
25446 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSectionStatementStorageClass ) * sizeOfActualPool) ;
25447 0 : delete [] storageArray;
25448 0 : SgOmpSectionStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25449 : }
25450 :
25451 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSectionsStatement );
25452 3 : storageClassIndex = 0 ;
25453 3 : if ( 0 < sizeOfActualPool )
25454 : {
25455 0 : SgOmpSectionsStatementStorageClass* storageArray = new SgOmpSectionsStatementStorageClass[sizeOfActualPool] ;
25456 0 : storageClassIndex = SgOmpSectionsStatement::initializeStorageClassArray (storageArray); ;
25457 0 : assert ( storageClassIndex == sizeOfActualPool );
25458 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSectionsStatementStorageClass ) * sizeOfActualPool) ;
25459 0 : delete [] storageArray;
25460 0 : SgOmpSectionsStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25461 : }
25462 :
25463 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSingleStatement );
25464 3 : storageClassIndex = 0 ;
25465 3 : if ( 0 < sizeOfActualPool )
25466 : {
25467 0 : SgOmpSingleStatementStorageClass* storageArray = new SgOmpSingleStatementStorageClass[sizeOfActualPool] ;
25468 0 : storageClassIndex = SgOmpSingleStatement::initializeStorageClassArray (storageArray); ;
25469 0 : assert ( storageClassIndex == sizeOfActualPool );
25470 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSingleStatementStorageClass ) * sizeOfActualPool) ;
25471 0 : delete [] storageArray;
25472 0 : SgOmpSingleStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25473 : }
25474 :
25475 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskStatement );
25476 3 : storageClassIndex = 0 ;
25477 3 : if ( 0 < sizeOfActualPool )
25478 : {
25479 0 : SgOmpTaskStatementStorageClass* storageArray = new SgOmpTaskStatementStorageClass[sizeOfActualPool] ;
25480 0 : storageClassIndex = SgOmpTaskStatement::initializeStorageClassArray (storageArray); ;
25481 0 : assert ( storageClassIndex == sizeOfActualPool );
25482 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskStatementStorageClass ) * sizeOfActualPool) ;
25483 0 : delete [] storageArray;
25484 0 : SgOmpTaskStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25485 : }
25486 :
25487 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskwaitStatement );
25488 3 : storageClassIndex = 0 ;
25489 3 : if ( 0 < sizeOfActualPool )
25490 : {
25491 0 : SgOmpTaskwaitStatementStorageClass* storageArray = new SgOmpTaskwaitStatementStorageClass[sizeOfActualPool] ;
25492 0 : storageClassIndex = SgOmpTaskwaitStatement::initializeStorageClassArray (storageArray); ;
25493 0 : assert ( storageClassIndex == sizeOfActualPool );
25494 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskwaitStatementStorageClass ) * sizeOfActualPool) ;
25495 0 : delete [] storageArray;
25496 0 : SgOmpTaskwaitStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25497 : }
25498 :
25499 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpThreadprivateStatement );
25500 3 : storageClassIndex = 0 ;
25501 3 : if ( 0 < sizeOfActualPool )
25502 : {
25503 0 : SgOmpThreadprivateStatementStorageClass* storageArray = new SgOmpThreadprivateStatementStorageClass[sizeOfActualPool] ;
25504 0 : storageClassIndex = SgOmpThreadprivateStatement::initializeStorageClassArray (storageArray); ;
25505 0 : assert ( storageClassIndex == sizeOfActualPool );
25506 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpThreadprivateStatementStorageClass ) * sizeOfActualPool) ;
25507 0 : delete [] storageArray;
25508 0 : SgOmpThreadprivateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25509 : }
25510 :
25511 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpWorkshareStatement );
25512 3 : storageClassIndex = 0 ;
25513 3 : if ( 0 < sizeOfActualPool )
25514 : {
25515 0 : SgOmpWorkshareStatementStorageClass* storageArray = new SgOmpWorkshareStatementStorageClass[sizeOfActualPool] ;
25516 0 : storageClassIndex = SgOmpWorkshareStatement::initializeStorageClassArray (storageArray); ;
25517 0 : assert ( storageClassIndex == sizeOfActualPool );
25518 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpWorkshareStatementStorageClass ) * sizeOfActualPool) ;
25519 0 : delete [] storageArray;
25520 0 : SgOmpWorkshareStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25521 : }
25522 :
25523 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirTaskStatement );
25524 3 : storageClassIndex = 0 ;
25525 3 : if ( 0 < sizeOfActualPool )
25526 : {
25527 0 : SgUpirTaskStatementStorageClass* storageArray = new SgUpirTaskStatementStorageClass[sizeOfActualPool] ;
25528 0 : storageClassIndex = SgUpirTaskStatement::initializeStorageClassArray (storageArray); ;
25529 0 : assert ( storageClassIndex == sizeOfActualPool );
25530 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirTaskStatementStorageClass ) * sizeOfActualPool) ;
25531 0 : delete [] storageArray;
25532 0 : SgUpirTaskStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25533 : }
25534 :
25535 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetDataStatement );
25536 3 : storageClassIndex = 0 ;
25537 3 : if ( 0 < sizeOfActualPool )
25538 : {
25539 0 : SgOmpTargetDataStatementStorageClass* storageArray = new SgOmpTargetDataStatementStorageClass[sizeOfActualPool] ;
25540 0 : storageClassIndex = SgOmpTargetDataStatement::initializeStorageClassArray (storageArray); ;
25541 0 : assert ( storageClassIndex == sizeOfActualPool );
25542 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetDataStatementStorageClass ) * sizeOfActualPool) ;
25543 0 : delete [] storageArray;
25544 0 : SgOmpTargetDataStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25545 : }
25546 :
25547 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetParallelForStatement );
25548 3 : storageClassIndex = 0 ;
25549 3 : if ( 0 < sizeOfActualPool )
25550 : {
25551 0 : SgOmpTargetParallelForStatementStorageClass* storageArray = new SgOmpTargetParallelForStatementStorageClass[sizeOfActualPool] ;
25552 0 : storageClassIndex = SgOmpTargetParallelForStatement::initializeStorageClassArray (storageArray); ;
25553 0 : assert ( storageClassIndex == sizeOfActualPool );
25554 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetParallelForStatementStorageClass ) * sizeOfActualPool) ;
25555 0 : delete [] storageArray;
25556 0 : SgOmpTargetParallelForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25557 : }
25558 :
25559 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetUpdateStatement );
25560 3 : storageClassIndex = 0 ;
25561 3 : if ( 0 < sizeOfActualPool )
25562 : {
25563 0 : SgOmpTargetUpdateStatementStorageClass* storageArray = new SgOmpTargetUpdateStatementStorageClass[sizeOfActualPool] ;
25564 0 : storageClassIndex = SgOmpTargetUpdateStatement::initializeStorageClassArray (storageArray); ;
25565 0 : assert ( storageClassIndex == sizeOfActualPool );
25566 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetUpdateStatementStorageClass ) * sizeOfActualPool) ;
25567 0 : delete [] storageArray;
25568 0 : SgOmpTargetUpdateStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25569 : }
25570 :
25571 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpRequiresStatement );
25572 3 : storageClassIndex = 0 ;
25573 3 : if ( 0 < sizeOfActualPool )
25574 : {
25575 0 : SgOmpRequiresStatementStorageClass* storageArray = new SgOmpRequiresStatementStorageClass[sizeOfActualPool] ;
25576 0 : storageClassIndex = SgOmpRequiresStatement::initializeStorageClassArray (storageArray); ;
25577 0 : assert ( storageClassIndex == sizeOfActualPool );
25578 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpRequiresStatementStorageClass ) * sizeOfActualPool) ;
25579 0 : delete [] storageArray;
25580 0 : SgOmpRequiresStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25581 : }
25582 :
25583 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetParallelStatement );
25584 3 : storageClassIndex = 0 ;
25585 3 : if ( 0 < sizeOfActualPool )
25586 : {
25587 0 : SgOmpTargetParallelStatementStorageClass* storageArray = new SgOmpTargetParallelStatementStorageClass[sizeOfActualPool] ;
25588 0 : storageClassIndex = SgOmpTargetParallelStatement::initializeStorageClassArray (storageArray); ;
25589 0 : assert ( storageClassIndex == sizeOfActualPool );
25590 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetParallelStatementStorageClass ) * sizeOfActualPool) ;
25591 0 : delete [] storageArray;
25592 0 : SgOmpTargetParallelStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25593 : }
25594 :
25595 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetParallelForSimdStatement );
25596 3 : storageClassIndex = 0 ;
25597 3 : if ( 0 < sizeOfActualPool )
25598 : {
25599 0 : SgOmpTargetParallelForSimdStatementStorageClass* storageArray = new SgOmpTargetParallelForSimdStatementStorageClass[sizeOfActualPool] ;
25600 0 : storageClassIndex = SgOmpTargetParallelForSimdStatement::initializeStorageClassArray (storageArray); ;
25601 0 : assert ( storageClassIndex == sizeOfActualPool );
25602 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
25603 0 : delete [] storageArray;
25604 0 : SgOmpTargetParallelForSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25605 : }
25606 :
25607 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetParallelLoopStatement );
25608 3 : storageClassIndex = 0 ;
25609 3 : if ( 0 < sizeOfActualPool )
25610 : {
25611 0 : SgOmpTargetParallelLoopStatementStorageClass* storageArray = new SgOmpTargetParallelLoopStatementStorageClass[sizeOfActualPool] ;
25612 0 : storageClassIndex = SgOmpTargetParallelLoopStatement::initializeStorageClassArray (storageArray); ;
25613 0 : assert ( storageClassIndex == sizeOfActualPool );
25614 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetParallelLoopStatementStorageClass ) * sizeOfActualPool) ;
25615 0 : delete [] storageArray;
25616 0 : SgOmpTargetParallelLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25617 : }
25618 :
25619 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetSimdStatement );
25620 3 : storageClassIndex = 0 ;
25621 3 : if ( 0 < sizeOfActualPool )
25622 : {
25623 0 : SgOmpTargetSimdStatementStorageClass* storageArray = new SgOmpTargetSimdStatementStorageClass[sizeOfActualPool] ;
25624 0 : storageClassIndex = SgOmpTargetSimdStatement::initializeStorageClassArray (storageArray); ;
25625 0 : assert ( storageClassIndex == sizeOfActualPool );
25626 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetSimdStatementStorageClass ) * sizeOfActualPool) ;
25627 0 : delete [] storageArray;
25628 0 : SgOmpTargetSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25629 : }
25630 :
25631 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsStatement );
25632 3 : storageClassIndex = 0 ;
25633 3 : if ( 0 < sizeOfActualPool )
25634 : {
25635 0 : SgOmpTargetTeamsStatementStorageClass* storageArray = new SgOmpTargetTeamsStatementStorageClass[sizeOfActualPool] ;
25636 0 : storageClassIndex = SgOmpTargetTeamsStatement::initializeStorageClassArray (storageArray); ;
25637 0 : assert ( storageClassIndex == sizeOfActualPool );
25638 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsStatementStorageClass ) * sizeOfActualPool) ;
25639 0 : delete [] storageArray;
25640 0 : SgOmpTargetTeamsStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25641 : }
25642 :
25643 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsDistributeStatement );
25644 3 : storageClassIndex = 0 ;
25645 3 : if ( 0 < sizeOfActualPool )
25646 : {
25647 0 : SgOmpTargetTeamsDistributeStatementStorageClass* storageArray = new SgOmpTargetTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
25648 0 : storageClassIndex = SgOmpTargetTeamsDistributeStatement::initializeStorageClassArray (storageArray); ;
25649 0 : assert ( storageClassIndex == sizeOfActualPool );
25650 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsDistributeStatementStorageClass ) * sizeOfActualPool) ;
25651 0 : delete [] storageArray;
25652 0 : SgOmpTargetTeamsDistributeStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25653 : }
25654 :
25655 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsDistributeSimdStatement );
25656 3 : storageClassIndex = 0 ;
25657 3 : if ( 0 < sizeOfActualPool )
25658 : {
25659 0 : SgOmpTargetTeamsDistributeSimdStatementStorageClass* storageArray = new SgOmpTargetTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
25660 0 : storageClassIndex = SgOmpTargetTeamsDistributeSimdStatement::initializeStorageClassArray (storageArray); ;
25661 0 : assert ( storageClassIndex == sizeOfActualPool );
25662 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
25663 0 : delete [] storageArray;
25664 0 : SgOmpTargetTeamsDistributeSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25665 : }
25666 :
25667 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsLoopStatement );
25668 3 : storageClassIndex = 0 ;
25669 3 : if ( 0 < sizeOfActualPool )
25670 : {
25671 0 : SgOmpTargetTeamsLoopStatementStorageClass* storageArray = new SgOmpTargetTeamsLoopStatementStorageClass[sizeOfActualPool] ;
25672 0 : storageClassIndex = SgOmpTargetTeamsLoopStatement::initializeStorageClassArray (storageArray); ;
25673 0 : assert ( storageClassIndex == sizeOfActualPool );
25674 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsLoopStatementStorageClass ) * sizeOfActualPool) ;
25675 0 : delete [] storageArray;
25676 0 : SgOmpTargetTeamsLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25677 : }
25678 :
25679 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsDistributeParallelForStatement );
25680 3 : storageClassIndex = 0 ;
25681 3 : if ( 0 < sizeOfActualPool )
25682 : {
25683 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass* storageArray = new SgOmpTargetTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
25684 0 : storageClassIndex = SgOmpTargetTeamsDistributeParallelForStatement::initializeStorageClassArray (storageArray); ;
25685 0 : assert ( storageClassIndex == sizeOfActualPool );
25686 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
25687 0 : delete [] storageArray;
25688 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25689 : }
25690 :
25691 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTargetTeamsDistributeParallelForSimdStatement );
25692 3 : storageClassIndex = 0 ;
25693 3 : if ( 0 < sizeOfActualPool )
25694 : {
25695 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass* storageArray = new SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
25696 0 : storageClassIndex = SgOmpTargetTeamsDistributeParallelForSimdStatement::initializeStorageClassArray (storageArray); ;
25697 0 : assert ( storageClassIndex == sizeOfActualPool );
25698 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
25699 0 : delete [] storageArray;
25700 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25701 : }
25702 :
25703 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDistributeSimdStatement );
25704 3 : storageClassIndex = 0 ;
25705 3 : if ( 0 < sizeOfActualPool )
25706 : {
25707 0 : SgOmpDistributeSimdStatementStorageClass* storageArray = new SgOmpDistributeSimdStatementStorageClass[sizeOfActualPool] ;
25708 0 : storageClassIndex = SgOmpDistributeSimdStatement::initializeStorageClassArray (storageArray); ;
25709 0 : assert ( storageClassIndex == sizeOfActualPool );
25710 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
25711 0 : delete [] storageArray;
25712 0 : SgOmpDistributeSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25713 : }
25714 :
25715 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDistributeParallelForStatement );
25716 3 : storageClassIndex = 0 ;
25717 3 : if ( 0 < sizeOfActualPool )
25718 : {
25719 0 : SgOmpDistributeParallelForStatementStorageClass* storageArray = new SgOmpDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
25720 0 : storageClassIndex = SgOmpDistributeParallelForStatement::initializeStorageClassArray (storageArray); ;
25721 0 : assert ( storageClassIndex == sizeOfActualPool );
25722 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
25723 0 : delete [] storageArray;
25724 0 : SgOmpDistributeParallelForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25725 : }
25726 :
25727 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDistributeParallelForSimdStatement );
25728 3 : storageClassIndex = 0 ;
25729 3 : if ( 0 < sizeOfActualPool )
25730 : {
25731 0 : SgOmpDistributeParallelForSimdStatementStorageClass* storageArray = new SgOmpDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
25732 0 : storageClassIndex = SgOmpDistributeParallelForSimdStatement::initializeStorageClassArray (storageArray); ;
25733 0 : assert ( storageClassIndex == sizeOfActualPool );
25734 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
25735 0 : delete [] storageArray;
25736 0 : SgOmpDistributeParallelForSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25737 : }
25738 :
25739 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskloopSimdStatement );
25740 3 : storageClassIndex = 0 ;
25741 3 : if ( 0 < sizeOfActualPool )
25742 : {
25743 0 : SgOmpTaskloopSimdStatementStorageClass* storageArray = new SgOmpTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
25744 0 : storageClassIndex = SgOmpTaskloopSimdStatement::initializeStorageClassArray (storageArray); ;
25745 0 : assert ( storageClassIndex == sizeOfActualPool );
25746 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
25747 0 : delete [] storageArray;
25748 0 : SgOmpTaskloopSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25749 : }
25750 :
25751 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMasterTaskloopSimdStatement );
25752 3 : storageClassIndex = 0 ;
25753 3 : if ( 0 < sizeOfActualPool )
25754 : {
25755 0 : SgOmpMasterTaskloopSimdStatementStorageClass* storageArray = new SgOmpMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
25756 0 : storageClassIndex = SgOmpMasterTaskloopSimdStatement::initializeStorageClassArray (storageArray); ;
25757 0 : assert ( storageClassIndex == sizeOfActualPool );
25758 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMasterTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
25759 0 : delete [] storageArray;
25760 0 : SgOmpMasterTaskloopSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25761 : }
25762 :
25763 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpParallelMasterTaskloopStatement );
25764 3 : storageClassIndex = 0 ;
25765 3 : if ( 0 < sizeOfActualPool )
25766 : {
25767 0 : SgOmpParallelMasterTaskloopStatementStorageClass* storageArray = new SgOmpParallelMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
25768 0 : storageClassIndex = SgOmpParallelMasterTaskloopStatement::initializeStorageClassArray (storageArray); ;
25769 0 : assert ( storageClassIndex == sizeOfActualPool );
25770 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpParallelMasterTaskloopStatementStorageClass ) * sizeOfActualPool) ;
25771 0 : delete [] storageArray;
25772 0 : SgOmpParallelMasterTaskloopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25773 : }
25774 :
25775 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpParallelMasterTaskloopSimdStatement );
25776 3 : storageClassIndex = 0 ;
25777 3 : if ( 0 < sizeOfActualPool )
25778 : {
25779 0 : SgOmpParallelMasterTaskloopSimdStatementStorageClass* storageArray = new SgOmpParallelMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
25780 0 : storageClassIndex = SgOmpParallelMasterTaskloopSimdStatement::initializeStorageClassArray (storageArray); ;
25781 0 : assert ( storageClassIndex == sizeOfActualPool );
25782 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpParallelMasterTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
25783 0 : delete [] storageArray;
25784 0 : SgOmpParallelMasterTaskloopSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25785 : }
25786 :
25787 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsDistributeStatement );
25788 3 : storageClassIndex = 0 ;
25789 3 : if ( 0 < sizeOfActualPool )
25790 : {
25791 0 : SgOmpTeamsDistributeStatementStorageClass* storageArray = new SgOmpTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
25792 0 : storageClassIndex = SgOmpTeamsDistributeStatement::initializeStorageClassArray (storageArray); ;
25793 0 : assert ( storageClassIndex == sizeOfActualPool );
25794 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsDistributeStatementStorageClass ) * sizeOfActualPool) ;
25795 0 : delete [] storageArray;
25796 0 : SgOmpTeamsDistributeStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25797 : }
25798 :
25799 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsDistributeSimdStatement );
25800 3 : storageClassIndex = 0 ;
25801 3 : if ( 0 < sizeOfActualPool )
25802 : {
25803 0 : SgOmpTeamsDistributeSimdStatementStorageClass* storageArray = new SgOmpTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
25804 0 : storageClassIndex = SgOmpTeamsDistributeSimdStatement::initializeStorageClassArray (storageArray); ;
25805 0 : assert ( storageClassIndex == sizeOfActualPool );
25806 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
25807 0 : delete [] storageArray;
25808 0 : SgOmpTeamsDistributeSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25809 : }
25810 :
25811 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsDistributeParallelForStatement );
25812 3 : storageClassIndex = 0 ;
25813 3 : if ( 0 < sizeOfActualPool )
25814 : {
25815 0 : SgOmpTeamsDistributeParallelForStatementStorageClass* storageArray = new SgOmpTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
25816 0 : storageClassIndex = SgOmpTeamsDistributeParallelForStatement::initializeStorageClassArray (storageArray); ;
25817 0 : assert ( storageClassIndex == sizeOfActualPool );
25818 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
25819 0 : delete [] storageArray;
25820 0 : SgOmpTeamsDistributeParallelForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25821 : }
25822 :
25823 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsDistributeParallelForSimdStatement );
25824 3 : storageClassIndex = 0 ;
25825 3 : if ( 0 < sizeOfActualPool )
25826 : {
25827 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass* storageArray = new SgOmpTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
25828 0 : storageClassIndex = SgOmpTeamsDistributeParallelForSimdStatement::initializeStorageClassArray (storageArray); ;
25829 0 : assert ( storageClassIndex == sizeOfActualPool );
25830 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
25831 0 : delete [] storageArray;
25832 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25833 : }
25834 :
25835 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTeamsLoopStatement );
25836 3 : storageClassIndex = 0 ;
25837 3 : if ( 0 < sizeOfActualPool )
25838 : {
25839 0 : SgOmpTeamsLoopStatementStorageClass* storageArray = new SgOmpTeamsLoopStatementStorageClass[sizeOfActualPool] ;
25840 0 : storageClassIndex = SgOmpTeamsLoopStatement::initializeStorageClassArray (storageArray); ;
25841 0 : assert ( storageClassIndex == sizeOfActualPool );
25842 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTeamsLoopStatementStorageClass ) * sizeOfActualPool) ;
25843 0 : delete [] storageArray;
25844 0 : SgOmpTeamsLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25845 : }
25846 :
25847 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpParallelLoopStatement );
25848 3 : storageClassIndex = 0 ;
25849 3 : if ( 0 < sizeOfActualPool )
25850 : {
25851 0 : SgOmpParallelLoopStatementStorageClass* storageArray = new SgOmpParallelLoopStatementStorageClass[sizeOfActualPool] ;
25852 0 : storageClassIndex = SgOmpParallelLoopStatement::initializeStorageClassArray (storageArray); ;
25853 0 : assert ( storageClassIndex == sizeOfActualPool );
25854 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpParallelLoopStatementStorageClass ) * sizeOfActualPool) ;
25855 0 : delete [] storageArray;
25856 0 : SgOmpParallelLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25857 : }
25858 :
25859 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpParallelMasterStatement );
25860 3 : storageClassIndex = 0 ;
25861 3 : if ( 0 < sizeOfActualPool )
25862 : {
25863 0 : SgOmpParallelMasterStatementStorageClass* storageArray = new SgOmpParallelMasterStatementStorageClass[sizeOfActualPool] ;
25864 0 : storageClassIndex = SgOmpParallelMasterStatement::initializeStorageClassArray (storageArray); ;
25865 0 : assert ( storageClassIndex == sizeOfActualPool );
25866 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpParallelMasterStatementStorageClass ) * sizeOfActualPool) ;
25867 0 : delete [] storageArray;
25868 0 : SgOmpParallelMasterStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25869 : }
25870 :
25871 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMasterTaskloopStatement );
25872 3 : storageClassIndex = 0 ;
25873 3 : if ( 0 < sizeOfActualPool )
25874 : {
25875 0 : SgOmpMasterTaskloopStatementStorageClass* storageArray = new SgOmpMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
25876 0 : storageClassIndex = SgOmpMasterTaskloopStatement::initializeStorageClassArray (storageArray); ;
25877 0 : assert ( storageClassIndex == sizeOfActualPool );
25878 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMasterTaskloopStatementStorageClass ) * sizeOfActualPool) ;
25879 0 : delete [] storageArray;
25880 0 : SgOmpMasterTaskloopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25881 : }
25882 :
25883 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUnrollStatement );
25884 3 : storageClassIndex = 0 ;
25885 3 : if ( 0 < sizeOfActualPool )
25886 : {
25887 0 : SgOmpUnrollStatementStorageClass* storageArray = new SgOmpUnrollStatementStorageClass[sizeOfActualPool] ;
25888 0 : storageClassIndex = SgOmpUnrollStatement::initializeStorageClassArray (storageArray); ;
25889 0 : assert ( storageClassIndex == sizeOfActualPool );
25890 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUnrollStatementStorageClass ) * sizeOfActualPool) ;
25891 0 : delete [] storageArray;
25892 0 : SgOmpUnrollStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25893 : }
25894 :
25895 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTileStatement );
25896 3 : storageClassIndex = 0 ;
25897 3 : if ( 0 < sizeOfActualPool )
25898 : {
25899 0 : SgOmpTileStatementStorageClass* storageArray = new SgOmpTileStatementStorageClass[sizeOfActualPool] ;
25900 0 : storageClassIndex = SgOmpTileStatement::initializeStorageClassArray (storageArray); ;
25901 0 : assert ( storageClassIndex == sizeOfActualPool );
25902 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTileStatementStorageClass ) * sizeOfActualPool) ;
25903 0 : delete [] storageArray;
25904 0 : SgOmpTileStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25905 : }
25906 :
25907 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirSimdStatement );
25908 3 : storageClassIndex = 0 ;
25909 3 : if ( 0 < sizeOfActualPool )
25910 : {
25911 0 : SgUpirSimdStatementStorageClass* storageArray = new SgUpirSimdStatementStorageClass[sizeOfActualPool] ;
25912 0 : storageClassIndex = SgUpirSimdStatement::initializeStorageClassArray (storageArray); ;
25913 0 : assert ( storageClassIndex == sizeOfActualPool );
25914 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirSimdStatementStorageClass ) * sizeOfActualPool) ;
25915 0 : delete [] storageArray;
25916 0 : SgUpirSimdStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25917 : }
25918 :
25919 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirBaseStatement );
25920 3 : storageClassIndex = 0 ;
25921 3 : if ( 0 < sizeOfActualPool )
25922 : {
25923 0 : SgUpirBaseStatementStorageClass* storageArray = new SgUpirBaseStatementStorageClass[sizeOfActualPool] ;
25924 0 : storageClassIndex = SgUpirBaseStatement::initializeStorageClassArray (storageArray); ;
25925 0 : assert ( storageClassIndex == sizeOfActualPool );
25926 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirBaseStatementStorageClass ) * sizeOfActualPool) ;
25927 0 : delete [] storageArray;
25928 0 : SgUpirBaseStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25929 : }
25930 :
25931 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirLoopStatement );
25932 3 : storageClassIndex = 0 ;
25933 3 : if ( 0 < sizeOfActualPool )
25934 : {
25935 0 : SgUpirLoopStatementStorageClass* storageArray = new SgUpirLoopStatementStorageClass[sizeOfActualPool] ;
25936 0 : storageClassIndex = SgUpirLoopStatement::initializeStorageClassArray (storageArray); ;
25937 0 : assert ( storageClassIndex == sizeOfActualPool );
25938 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirLoopStatementStorageClass ) * sizeOfActualPool) ;
25939 0 : delete [] storageArray;
25940 0 : SgUpirLoopStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25941 : }
25942 :
25943 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirLoopParallelStatement );
25944 3 : storageClassIndex = 0 ;
25945 3 : if ( 0 < sizeOfActualPool )
25946 : {
25947 0 : SgUpirLoopParallelStatementStorageClass* storageArray = new SgUpirLoopParallelStatementStorageClass[sizeOfActualPool] ;
25948 0 : storageClassIndex = SgUpirLoopParallelStatement::initializeStorageClassArray (storageArray); ;
25949 0 : assert ( storageClassIndex == sizeOfActualPool );
25950 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirLoopParallelStatementStorageClass ) * sizeOfActualPool) ;
25951 0 : delete [] storageArray;
25952 0 : SgUpirLoopParallelStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25953 : }
25954 :
25955 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirSyncStatement );
25956 3 : storageClassIndex = 0 ;
25957 3 : if ( 0 < sizeOfActualPool )
25958 : {
25959 0 : SgUpirSyncStatementStorageClass* storageArray = new SgUpirSyncStatementStorageClass[sizeOfActualPool] ;
25960 0 : storageClassIndex = SgUpirSyncStatement::initializeStorageClassArray (storageArray); ;
25961 0 : assert ( storageClassIndex == sizeOfActualPool );
25962 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirSyncStatementStorageClass ) * sizeOfActualPool) ;
25963 0 : delete [] storageArray;
25964 0 : SgUpirSyncStatementStorageClass :: writeEasyStorageDataToFile(out) ;
25965 : }
25966 :
25967 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpClause );
25968 3 : storageClassIndex = 0 ;
25969 3 : if ( 0 < sizeOfActualPool )
25970 : {
25971 0 : SgOmpClauseStorageClass* storageArray = new SgOmpClauseStorageClass[sizeOfActualPool] ;
25972 0 : storageClassIndex = SgOmpClause::initializeStorageClassArray (storageArray); ;
25973 0 : assert ( storageClassIndex == sizeOfActualPool );
25974 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpClauseStorageClass ) * sizeOfActualPool) ;
25975 0 : delete [] storageArray;
25976 0 : SgOmpClauseStorageClass :: writeEasyStorageDataToFile(out) ;
25977 : }
25978 :
25979 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAllocateClause );
25980 3 : storageClassIndex = 0 ;
25981 3 : if ( 0 < sizeOfActualPool )
25982 : {
25983 0 : SgOmpAllocateClauseStorageClass* storageArray = new SgOmpAllocateClauseStorageClass[sizeOfActualPool] ;
25984 0 : storageClassIndex = SgOmpAllocateClause::initializeStorageClassArray (storageArray); ;
25985 0 : assert ( storageClassIndex == sizeOfActualPool );
25986 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAllocateClauseStorageClass ) * sizeOfActualPool) ;
25987 0 : delete [] storageArray;
25988 0 : SgOmpAllocateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
25989 : }
25990 :
25991 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAllocatorClause );
25992 3 : storageClassIndex = 0 ;
25993 3 : if ( 0 < sizeOfActualPool )
25994 : {
25995 0 : SgOmpAllocatorClauseStorageClass* storageArray = new SgOmpAllocatorClauseStorageClass[sizeOfActualPool] ;
25996 0 : storageClassIndex = SgOmpAllocatorClause::initializeStorageClassArray (storageArray); ;
25997 0 : assert ( storageClassIndex == sizeOfActualPool );
25998 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAllocatorClauseStorageClass ) * sizeOfActualPool) ;
25999 0 : delete [] storageArray;
26000 0 : SgOmpAllocatorClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26001 : }
26002 :
26003 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUsesAllocatorsClause );
26004 3 : storageClassIndex = 0 ;
26005 3 : if ( 0 < sizeOfActualPool )
26006 : {
26007 0 : SgOmpUsesAllocatorsClauseStorageClass* storageArray = new SgOmpUsesAllocatorsClauseStorageClass[sizeOfActualPool] ;
26008 0 : storageClassIndex = SgOmpUsesAllocatorsClause::initializeStorageClassArray (storageArray); ;
26009 0 : assert ( storageClassIndex == sizeOfActualPool );
26010 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUsesAllocatorsClauseStorageClass ) * sizeOfActualPool) ;
26011 0 : delete [] storageArray;
26012 0 : SgOmpUsesAllocatorsClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26013 : }
26014 :
26015 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUsesAllocatorsDefination );
26016 3 : storageClassIndex = 0 ;
26017 3 : if ( 0 < sizeOfActualPool )
26018 : {
26019 0 : SgOmpUsesAllocatorsDefinationStorageClass* storageArray = new SgOmpUsesAllocatorsDefinationStorageClass[sizeOfActualPool] ;
26020 0 : storageClassIndex = SgOmpUsesAllocatorsDefination::initializeStorageClassArray (storageArray); ;
26021 0 : assert ( storageClassIndex == sizeOfActualPool );
26022 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUsesAllocatorsDefinationStorageClass ) * sizeOfActualPool) ;
26023 0 : delete [] storageArray;
26024 0 : SgOmpUsesAllocatorsDefinationStorageClass :: writeEasyStorageDataToFile(out) ;
26025 : }
26026 :
26027 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpToClause );
26028 3 : storageClassIndex = 0 ;
26029 3 : if ( 0 < sizeOfActualPool )
26030 : {
26031 0 : SgOmpToClauseStorageClass* storageArray = new SgOmpToClauseStorageClass[sizeOfActualPool] ;
26032 0 : storageClassIndex = SgOmpToClause::initializeStorageClassArray (storageArray); ;
26033 0 : assert ( storageClassIndex == sizeOfActualPool );
26034 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpToClauseStorageClass ) * sizeOfActualPool) ;
26035 0 : delete [] storageArray;
26036 0 : SgOmpToClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26037 : }
26038 :
26039 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpFromClause );
26040 3 : storageClassIndex = 0 ;
26041 3 : if ( 0 < sizeOfActualPool )
26042 : {
26043 0 : SgOmpFromClauseStorageClass* storageArray = new SgOmpFromClauseStorageClass[sizeOfActualPool] ;
26044 0 : storageClassIndex = SgOmpFromClause::initializeStorageClassArray (storageArray); ;
26045 0 : assert ( storageClassIndex == sizeOfActualPool );
26046 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpFromClauseStorageClass ) * sizeOfActualPool) ;
26047 0 : delete [] storageArray;
26048 0 : SgOmpFromClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26049 : }
26050 :
26051 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpThreadsClause );
26052 3 : storageClassIndex = 0 ;
26053 3 : if ( 0 < sizeOfActualPool )
26054 : {
26055 0 : SgOmpThreadsClauseStorageClass* storageArray = new SgOmpThreadsClauseStorageClass[sizeOfActualPool] ;
26056 0 : storageClassIndex = SgOmpThreadsClause::initializeStorageClassArray (storageArray); ;
26057 0 : assert ( storageClassIndex == sizeOfActualPool );
26058 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpThreadsClauseStorageClass ) * sizeOfActualPool) ;
26059 0 : delete [] storageArray;
26060 0 : SgOmpThreadsClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26061 : }
26062 :
26063 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSimdClause );
26064 3 : storageClassIndex = 0 ;
26065 3 : if ( 0 < sizeOfActualPool )
26066 : {
26067 0 : SgOmpSimdClauseStorageClass* storageArray = new SgOmpSimdClauseStorageClass[sizeOfActualPool] ;
26068 0 : storageClassIndex = SgOmpSimdClause::initializeStorageClassArray (storageArray); ;
26069 0 : assert ( storageClassIndex == sizeOfActualPool );
26070 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSimdClauseStorageClass ) * sizeOfActualPool) ;
26071 0 : delete [] storageArray;
26072 0 : SgOmpSimdClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26073 : }
26074 :
26075 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpBeginClause );
26076 3 : storageClassIndex = 0 ;
26077 3 : if ( 0 < sizeOfActualPool )
26078 : {
26079 0 : SgOmpBeginClauseStorageClass* storageArray = new SgOmpBeginClauseStorageClass[sizeOfActualPool] ;
26080 0 : storageClassIndex = SgOmpBeginClause::initializeStorageClassArray (storageArray); ;
26081 0 : assert ( storageClassIndex == sizeOfActualPool );
26082 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpBeginClauseStorageClass ) * sizeOfActualPool) ;
26083 0 : delete [] storageArray;
26084 0 : SgOmpBeginClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26085 : }
26086 :
26087 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCollapseClause );
26088 3 : storageClassIndex = 0 ;
26089 3 : if ( 0 < sizeOfActualPool )
26090 : {
26091 0 : SgOmpCollapseClauseStorageClass* storageArray = new SgOmpCollapseClauseStorageClass[sizeOfActualPool] ;
26092 0 : storageClassIndex = SgOmpCollapseClause::initializeStorageClassArray (storageArray); ;
26093 0 : assert ( storageClassIndex == sizeOfActualPool );
26094 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCollapseClauseStorageClass ) * sizeOfActualPool) ;
26095 0 : delete [] storageArray;
26096 0 : SgOmpCollapseClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26097 : }
26098 :
26099 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCopyinClause );
26100 3 : storageClassIndex = 0 ;
26101 3 : if ( 0 < sizeOfActualPool )
26102 : {
26103 0 : SgOmpCopyinClauseStorageClass* storageArray = new SgOmpCopyinClauseStorageClass[sizeOfActualPool] ;
26104 0 : storageClassIndex = SgOmpCopyinClause::initializeStorageClassArray (storageArray); ;
26105 0 : assert ( storageClassIndex == sizeOfActualPool );
26106 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCopyinClauseStorageClass ) * sizeOfActualPool) ;
26107 0 : delete [] storageArray;
26108 0 : SgOmpCopyinClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26109 : }
26110 :
26111 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCopyprivateClause );
26112 3 : storageClassIndex = 0 ;
26113 3 : if ( 0 < sizeOfActualPool )
26114 : {
26115 0 : SgOmpCopyprivateClauseStorageClass* storageArray = new SgOmpCopyprivateClauseStorageClass[sizeOfActualPool] ;
26116 0 : storageClassIndex = SgOmpCopyprivateClause::initializeStorageClassArray (storageArray); ;
26117 0 : assert ( storageClassIndex == sizeOfActualPool );
26118 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCopyprivateClauseStorageClass ) * sizeOfActualPool) ;
26119 0 : delete [] storageArray;
26120 0 : SgOmpCopyprivateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26121 : }
26122 :
26123 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDefaultClause );
26124 3 : storageClassIndex = 0 ;
26125 3 : if ( 0 < sizeOfActualPool )
26126 : {
26127 0 : SgOmpDefaultClauseStorageClass* storageArray = new SgOmpDefaultClauseStorageClass[sizeOfActualPool] ;
26128 0 : storageClassIndex = SgOmpDefaultClause::initializeStorageClassArray (storageArray); ;
26129 0 : assert ( storageClassIndex == sizeOfActualPool );
26130 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDefaultClauseStorageClass ) * sizeOfActualPool) ;
26131 0 : delete [] storageArray;
26132 0 : SgOmpDefaultClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26133 : }
26134 :
26135 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpEndClause );
26136 3 : storageClassIndex = 0 ;
26137 3 : if ( 0 < sizeOfActualPool )
26138 : {
26139 0 : SgOmpEndClauseStorageClass* storageArray = new SgOmpEndClauseStorageClass[sizeOfActualPool] ;
26140 0 : storageClassIndex = SgOmpEndClause::initializeStorageClassArray (storageArray); ;
26141 0 : assert ( storageClassIndex == sizeOfActualPool );
26142 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpEndClauseStorageClass ) * sizeOfActualPool) ;
26143 0 : delete [] storageArray;
26144 0 : SgOmpEndClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26145 : }
26146 :
26147 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpExpressionClause );
26148 3 : storageClassIndex = 0 ;
26149 3 : if ( 0 < sizeOfActualPool )
26150 : {
26151 0 : SgOmpExpressionClauseStorageClass* storageArray = new SgOmpExpressionClauseStorageClass[sizeOfActualPool] ;
26152 0 : storageClassIndex = SgOmpExpressionClause::initializeStorageClassArray (storageArray); ;
26153 0 : assert ( storageClassIndex == sizeOfActualPool );
26154 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpExpressionClauseStorageClass ) * sizeOfActualPool) ;
26155 0 : delete [] storageArray;
26156 0 : SgOmpExpressionClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26157 : }
26158 :
26159 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpFirstprivateClause );
26160 3 : storageClassIndex = 0 ;
26161 3 : if ( 0 < sizeOfActualPool )
26162 : {
26163 0 : SgOmpFirstprivateClauseStorageClass* storageArray = new SgOmpFirstprivateClauseStorageClass[sizeOfActualPool] ;
26164 0 : storageClassIndex = SgOmpFirstprivateClause::initializeStorageClassArray (storageArray); ;
26165 0 : assert ( storageClassIndex == sizeOfActualPool );
26166 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpFirstprivateClauseStorageClass ) * sizeOfActualPool) ;
26167 0 : delete [] storageArray;
26168 0 : SgOmpFirstprivateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26169 : }
26170 :
26171 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpIfClause );
26172 3 : storageClassIndex = 0 ;
26173 3 : if ( 0 < sizeOfActualPool )
26174 : {
26175 0 : SgOmpIfClauseStorageClass* storageArray = new SgOmpIfClauseStorageClass[sizeOfActualPool] ;
26176 0 : storageClassIndex = SgOmpIfClause::initializeStorageClassArray (storageArray); ;
26177 0 : assert ( storageClassIndex == sizeOfActualPool );
26178 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpIfClauseStorageClass ) * sizeOfActualPool) ;
26179 0 : delete [] storageArray;
26180 0 : SgOmpIfClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26181 : }
26182 :
26183 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpFinalClause );
26184 3 : storageClassIndex = 0 ;
26185 3 : if ( 0 < sizeOfActualPool )
26186 : {
26187 0 : SgOmpFinalClauseStorageClass* storageArray = new SgOmpFinalClauseStorageClass[sizeOfActualPool] ;
26188 0 : storageClassIndex = SgOmpFinalClause::initializeStorageClassArray (storageArray); ;
26189 0 : assert ( storageClassIndex == sizeOfActualPool );
26190 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpFinalClauseStorageClass ) * sizeOfActualPool) ;
26191 0 : delete [] storageArray;
26192 0 : SgOmpFinalClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26193 : }
26194 :
26195 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpPriorityClause );
26196 3 : storageClassIndex = 0 ;
26197 3 : if ( 0 < sizeOfActualPool )
26198 : {
26199 0 : SgOmpPriorityClauseStorageClass* storageArray = new SgOmpPriorityClauseStorageClass[sizeOfActualPool] ;
26200 0 : storageClassIndex = SgOmpPriorityClause::initializeStorageClassArray (storageArray); ;
26201 0 : assert ( storageClassIndex == sizeOfActualPool );
26202 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpPriorityClauseStorageClass ) * sizeOfActualPool) ;
26203 0 : delete [] storageArray;
26204 0 : SgOmpPriorityClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26205 : }
26206 :
26207 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDeviceClause );
26208 3 : storageClassIndex = 0 ;
26209 3 : if ( 0 < sizeOfActualPool )
26210 : {
26211 0 : SgOmpDeviceClauseStorageClass* storageArray = new SgOmpDeviceClauseStorageClass[sizeOfActualPool] ;
26212 0 : storageClassIndex = SgOmpDeviceClause::initializeStorageClassArray (storageArray); ;
26213 0 : assert ( storageClassIndex == sizeOfActualPool );
26214 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDeviceClauseStorageClass ) * sizeOfActualPool) ;
26215 0 : delete [] storageArray;
26216 0 : SgOmpDeviceClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26217 : }
26218 :
26219 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpLastprivateClause );
26220 3 : storageClassIndex = 0 ;
26221 3 : if ( 0 < sizeOfActualPool )
26222 : {
26223 0 : SgOmpLastprivateClauseStorageClass* storageArray = new SgOmpLastprivateClauseStorageClass[sizeOfActualPool] ;
26224 0 : storageClassIndex = SgOmpLastprivateClause::initializeStorageClassArray (storageArray); ;
26225 0 : assert ( storageClassIndex == sizeOfActualPool );
26226 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpLastprivateClauseStorageClass ) * sizeOfActualPool) ;
26227 0 : delete [] storageArray;
26228 0 : SgOmpLastprivateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26229 : }
26230 :
26231 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNowaitClause );
26232 3 : storageClassIndex = 0 ;
26233 3 : if ( 0 < sizeOfActualPool )
26234 : {
26235 0 : SgOmpNowaitClauseStorageClass* storageArray = new SgOmpNowaitClauseStorageClass[sizeOfActualPool] ;
26236 0 : storageClassIndex = SgOmpNowaitClause::initializeStorageClassArray (storageArray); ;
26237 0 : assert ( storageClassIndex == sizeOfActualPool );
26238 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNowaitClauseStorageClass ) * sizeOfActualPool) ;
26239 0 : delete [] storageArray;
26240 0 : SgOmpNowaitClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26241 : }
26242 :
26243 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpReadClause );
26244 3 : storageClassIndex = 0 ;
26245 3 : if ( 0 < sizeOfActualPool )
26246 : {
26247 0 : SgOmpReadClauseStorageClass* storageArray = new SgOmpReadClauseStorageClass[sizeOfActualPool] ;
26248 0 : storageClassIndex = SgOmpReadClause::initializeStorageClassArray (storageArray); ;
26249 0 : assert ( storageClassIndex == sizeOfActualPool );
26250 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpReadClauseStorageClass ) * sizeOfActualPool) ;
26251 0 : delete [] storageArray;
26252 0 : SgOmpReadClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26253 : }
26254 :
26255 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpWriteClause );
26256 3 : storageClassIndex = 0 ;
26257 3 : if ( 0 < sizeOfActualPool )
26258 : {
26259 0 : SgOmpWriteClauseStorageClass* storageArray = new SgOmpWriteClauseStorageClass[sizeOfActualPool] ;
26260 0 : storageClassIndex = SgOmpWriteClause::initializeStorageClassArray (storageArray); ;
26261 0 : assert ( storageClassIndex == sizeOfActualPool );
26262 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpWriteClauseStorageClass ) * sizeOfActualPool) ;
26263 0 : delete [] storageArray;
26264 0 : SgOmpWriteClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26265 : }
26266 :
26267 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUpdateClause );
26268 3 : storageClassIndex = 0 ;
26269 3 : if ( 0 < sizeOfActualPool )
26270 : {
26271 0 : SgOmpUpdateClauseStorageClass* storageArray = new SgOmpUpdateClauseStorageClass[sizeOfActualPool] ;
26272 0 : storageClassIndex = SgOmpUpdateClause::initializeStorageClassArray (storageArray); ;
26273 0 : assert ( storageClassIndex == sizeOfActualPool );
26274 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUpdateClauseStorageClass ) * sizeOfActualPool) ;
26275 0 : delete [] storageArray;
26276 0 : SgOmpUpdateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26277 : }
26278 :
26279 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDepobjUpdateClause );
26280 3 : storageClassIndex = 0 ;
26281 3 : if ( 0 < sizeOfActualPool )
26282 : {
26283 0 : SgOmpDepobjUpdateClauseStorageClass* storageArray = new SgOmpDepobjUpdateClauseStorageClass[sizeOfActualPool] ;
26284 0 : storageClassIndex = SgOmpDepobjUpdateClause::initializeStorageClassArray (storageArray); ;
26285 0 : assert ( storageClassIndex == sizeOfActualPool );
26286 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDepobjUpdateClauseStorageClass ) * sizeOfActualPool) ;
26287 0 : delete [] storageArray;
26288 0 : SgOmpDepobjUpdateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26289 : }
26290 :
26291 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDestroyClause );
26292 3 : storageClassIndex = 0 ;
26293 3 : if ( 0 < sizeOfActualPool )
26294 : {
26295 0 : SgOmpDestroyClauseStorageClass* storageArray = new SgOmpDestroyClauseStorageClass[sizeOfActualPool] ;
26296 0 : storageClassIndex = SgOmpDestroyClause::initializeStorageClassArray (storageArray); ;
26297 0 : assert ( storageClassIndex == sizeOfActualPool );
26298 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDestroyClauseStorageClass ) * sizeOfActualPool) ;
26299 0 : delete [] storageArray;
26300 0 : SgOmpDestroyClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26301 : }
26302 :
26303 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpCaptureClause );
26304 3 : storageClassIndex = 0 ;
26305 3 : if ( 0 < sizeOfActualPool )
26306 : {
26307 0 : SgOmpCaptureClauseStorageClass* storageArray = new SgOmpCaptureClauseStorageClass[sizeOfActualPool] ;
26308 0 : storageClassIndex = SgOmpCaptureClause::initializeStorageClassArray (storageArray); ;
26309 0 : assert ( storageClassIndex == sizeOfActualPool );
26310 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpCaptureClauseStorageClass ) * sizeOfActualPool) ;
26311 0 : delete [] storageArray;
26312 0 : SgOmpCaptureClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26313 : }
26314 :
26315 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSeqCstClause );
26316 3 : storageClassIndex = 0 ;
26317 3 : if ( 0 < sizeOfActualPool )
26318 : {
26319 0 : SgOmpSeqCstClauseStorageClass* storageArray = new SgOmpSeqCstClauseStorageClass[sizeOfActualPool] ;
26320 0 : storageClassIndex = SgOmpSeqCstClause::initializeStorageClassArray (storageArray); ;
26321 0 : assert ( storageClassIndex == sizeOfActualPool );
26322 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSeqCstClauseStorageClass ) * sizeOfActualPool) ;
26323 0 : delete [] storageArray;
26324 0 : SgOmpSeqCstClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26325 : }
26326 :
26327 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAcqRelClause );
26328 3 : storageClassIndex = 0 ;
26329 3 : if ( 0 < sizeOfActualPool )
26330 : {
26331 0 : SgOmpAcqRelClauseStorageClass* storageArray = new SgOmpAcqRelClauseStorageClass[sizeOfActualPool] ;
26332 0 : storageClassIndex = SgOmpAcqRelClause::initializeStorageClassArray (storageArray); ;
26333 0 : assert ( storageClassIndex == sizeOfActualPool );
26334 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAcqRelClauseStorageClass ) * sizeOfActualPool) ;
26335 0 : delete [] storageArray;
26336 0 : SgOmpAcqRelClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26337 : }
26338 :
26339 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpReleaseClause );
26340 3 : storageClassIndex = 0 ;
26341 3 : if ( 0 < sizeOfActualPool )
26342 : {
26343 0 : SgOmpReleaseClauseStorageClass* storageArray = new SgOmpReleaseClauseStorageClass[sizeOfActualPool] ;
26344 0 : storageClassIndex = SgOmpReleaseClause::initializeStorageClassArray (storageArray); ;
26345 0 : assert ( storageClassIndex == sizeOfActualPool );
26346 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpReleaseClauseStorageClass ) * sizeOfActualPool) ;
26347 0 : delete [] storageArray;
26348 0 : SgOmpReleaseClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26349 : }
26350 :
26351 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAcquireClause );
26352 3 : storageClassIndex = 0 ;
26353 3 : if ( 0 < sizeOfActualPool )
26354 : {
26355 0 : SgOmpAcquireClauseStorageClass* storageArray = new SgOmpAcquireClauseStorageClass[sizeOfActualPool] ;
26356 0 : storageClassIndex = SgOmpAcquireClause::initializeStorageClassArray (storageArray); ;
26357 0 : assert ( storageClassIndex == sizeOfActualPool );
26358 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAcquireClauseStorageClass ) * sizeOfActualPool) ;
26359 0 : delete [] storageArray;
26360 0 : SgOmpAcquireClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26361 : }
26362 :
26363 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpReverseOffloadClause );
26364 3 : storageClassIndex = 0 ;
26365 3 : if ( 0 < sizeOfActualPool )
26366 : {
26367 0 : SgOmpReverseOffloadClauseStorageClass* storageArray = new SgOmpReverseOffloadClauseStorageClass[sizeOfActualPool] ;
26368 0 : storageClassIndex = SgOmpReverseOffloadClause::initializeStorageClassArray (storageArray); ;
26369 0 : assert ( storageClassIndex == sizeOfActualPool );
26370 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpReverseOffloadClauseStorageClass ) * sizeOfActualPool) ;
26371 0 : delete [] storageArray;
26372 0 : SgOmpReverseOffloadClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26373 : }
26374 :
26375 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUnifiedAddressClause );
26376 3 : storageClassIndex = 0 ;
26377 3 : if ( 0 < sizeOfActualPool )
26378 : {
26379 0 : SgOmpUnifiedAddressClauseStorageClass* storageArray = new SgOmpUnifiedAddressClauseStorageClass[sizeOfActualPool] ;
26380 0 : storageClassIndex = SgOmpUnifiedAddressClause::initializeStorageClassArray (storageArray); ;
26381 0 : assert ( storageClassIndex == sizeOfActualPool );
26382 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUnifiedAddressClauseStorageClass ) * sizeOfActualPool) ;
26383 0 : delete [] storageArray;
26384 0 : SgOmpUnifiedAddressClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26385 : }
26386 :
26387 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUnifiedSharedMemoryClause );
26388 3 : storageClassIndex = 0 ;
26389 3 : if ( 0 < sizeOfActualPool )
26390 : {
26391 0 : SgOmpUnifiedSharedMemoryClauseStorageClass* storageArray = new SgOmpUnifiedSharedMemoryClauseStorageClass[sizeOfActualPool] ;
26392 0 : storageClassIndex = SgOmpUnifiedSharedMemoryClause::initializeStorageClassArray (storageArray); ;
26393 0 : assert ( storageClassIndex == sizeOfActualPool );
26394 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUnifiedSharedMemoryClauseStorageClass ) * sizeOfActualPool) ;
26395 0 : delete [] storageArray;
26396 0 : SgOmpUnifiedSharedMemoryClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26397 : }
26398 :
26399 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDynamicAllocatorsClause );
26400 3 : storageClassIndex = 0 ;
26401 3 : if ( 0 < sizeOfActualPool )
26402 : {
26403 0 : SgOmpDynamicAllocatorsClauseStorageClass* storageArray = new SgOmpDynamicAllocatorsClauseStorageClass[sizeOfActualPool] ;
26404 0 : storageClassIndex = SgOmpDynamicAllocatorsClause::initializeStorageClassArray (storageArray); ;
26405 0 : assert ( storageClassIndex == sizeOfActualPool );
26406 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDynamicAllocatorsClauseStorageClass ) * sizeOfActualPool) ;
26407 0 : delete [] storageArray;
26408 0 : SgOmpDynamicAllocatorsClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26409 : }
26410 :
26411 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAtomicDefaultMemOrderClause );
26412 3 : storageClassIndex = 0 ;
26413 3 : if ( 0 < sizeOfActualPool )
26414 : {
26415 0 : SgOmpAtomicDefaultMemOrderClauseStorageClass* storageArray = new SgOmpAtomicDefaultMemOrderClauseStorageClass[sizeOfActualPool] ;
26416 0 : storageClassIndex = SgOmpAtomicDefaultMemOrderClause::initializeStorageClassArray (storageArray); ;
26417 0 : assert ( storageClassIndex == sizeOfActualPool );
26418 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAtomicDefaultMemOrderClauseStorageClass ) * sizeOfActualPool) ;
26419 0 : delete [] storageArray;
26420 0 : SgOmpAtomicDefaultMemOrderClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26421 : }
26422 :
26423 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpExtImplementationDefinedRequirementClause );
26424 3 : storageClassIndex = 0 ;
26425 3 : if ( 0 < sizeOfActualPool )
26426 : {
26427 0 : SgOmpExtImplementationDefinedRequirementClauseStorageClass* storageArray = new SgOmpExtImplementationDefinedRequirementClauseStorageClass[sizeOfActualPool] ;
26428 0 : storageClassIndex = SgOmpExtImplementationDefinedRequirementClause::initializeStorageClassArray (storageArray); ;
26429 0 : assert ( storageClassIndex == sizeOfActualPool );
26430 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpExtImplementationDefinedRequirementClauseStorageClass ) * sizeOfActualPool) ;
26431 0 : delete [] storageArray;
26432 0 : SgOmpExtImplementationDefinedRequirementClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26433 : }
26434 :
26435 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpRelaxedClause );
26436 3 : storageClassIndex = 0 ;
26437 3 : if ( 0 < sizeOfActualPool )
26438 : {
26439 0 : SgOmpRelaxedClauseStorageClass* storageArray = new SgOmpRelaxedClauseStorageClass[sizeOfActualPool] ;
26440 0 : storageClassIndex = SgOmpRelaxedClause::initializeStorageClassArray (storageArray); ;
26441 0 : assert ( storageClassIndex == sizeOfActualPool );
26442 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpRelaxedClauseStorageClass ) * sizeOfActualPool) ;
26443 0 : delete [] storageArray;
26444 0 : SgOmpRelaxedClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26445 : }
26446 :
26447 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpParallelClause );
26448 3 : storageClassIndex = 0 ;
26449 3 : if ( 0 < sizeOfActualPool )
26450 : {
26451 0 : SgOmpParallelClauseStorageClass* storageArray = new SgOmpParallelClauseStorageClass[sizeOfActualPool] ;
26452 0 : storageClassIndex = SgOmpParallelClause::initializeStorageClassArray (storageArray); ;
26453 0 : assert ( storageClassIndex == sizeOfActualPool );
26454 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpParallelClauseStorageClass ) * sizeOfActualPool) ;
26455 0 : delete [] storageArray;
26456 0 : SgOmpParallelClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26457 : }
26458 :
26459 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSectionsClause );
26460 3 : storageClassIndex = 0 ;
26461 3 : if ( 0 < sizeOfActualPool )
26462 : {
26463 0 : SgOmpSectionsClauseStorageClass* storageArray = new SgOmpSectionsClauseStorageClass[sizeOfActualPool] ;
26464 0 : storageClassIndex = SgOmpSectionsClause::initializeStorageClassArray (storageArray); ;
26465 0 : assert ( storageClassIndex == sizeOfActualPool );
26466 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSectionsClauseStorageClass ) * sizeOfActualPool) ;
26467 0 : delete [] storageArray;
26468 0 : SgOmpSectionsClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26469 : }
26470 :
26471 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpForClause );
26472 3 : storageClassIndex = 0 ;
26473 3 : if ( 0 < sizeOfActualPool )
26474 : {
26475 0 : SgOmpForClauseStorageClass* storageArray = new SgOmpForClauseStorageClass[sizeOfActualPool] ;
26476 0 : storageClassIndex = SgOmpForClause::initializeStorageClassArray (storageArray); ;
26477 0 : assert ( storageClassIndex == sizeOfActualPool );
26478 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpForClauseStorageClass ) * sizeOfActualPool) ;
26479 0 : delete [] storageArray;
26480 0 : SgOmpForClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26481 : }
26482 :
26483 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskgroupClause );
26484 3 : storageClassIndex = 0 ;
26485 3 : if ( 0 < sizeOfActualPool )
26486 : {
26487 0 : SgOmpTaskgroupClauseStorageClass* storageArray = new SgOmpTaskgroupClauseStorageClass[sizeOfActualPool] ;
26488 0 : storageClassIndex = SgOmpTaskgroupClause::initializeStorageClassArray (storageArray); ;
26489 0 : assert ( storageClassIndex == sizeOfActualPool );
26490 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskgroupClauseStorageClass ) * sizeOfActualPool) ;
26491 0 : delete [] storageArray;
26492 0 : SgOmpTaskgroupClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26493 : }
26494 :
26495 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirNumUnitsField );
26496 3 : storageClassIndex = 0 ;
26497 3 : if ( 0 < sizeOfActualPool )
26498 : {
26499 0 : SgUpirNumUnitsFieldStorageClass* storageArray = new SgUpirNumUnitsFieldStorageClass[sizeOfActualPool] ;
26500 0 : storageClassIndex = SgUpirNumUnitsField::initializeStorageClassArray (storageArray); ;
26501 0 : assert ( storageClassIndex == sizeOfActualPool );
26502 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirNumUnitsFieldStorageClass ) * sizeOfActualPool) ;
26503 0 : delete [] storageArray;
26504 0 : SgUpirNumUnitsFieldStorageClass :: writeEasyStorageDataToFile(out) ;
26505 : }
26506 :
26507 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNumTeamsClause );
26508 3 : storageClassIndex = 0 ;
26509 3 : if ( 0 < sizeOfActualPool )
26510 : {
26511 0 : SgOmpNumTeamsClauseStorageClass* storageArray = new SgOmpNumTeamsClauseStorageClass[sizeOfActualPool] ;
26512 0 : storageClassIndex = SgOmpNumTeamsClause::initializeStorageClassArray (storageArray); ;
26513 0 : assert ( storageClassIndex == sizeOfActualPool );
26514 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNumTeamsClauseStorageClass ) * sizeOfActualPool) ;
26515 0 : delete [] storageArray;
26516 0 : SgOmpNumTeamsClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26517 : }
26518 :
26519 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpGrainsizeClause );
26520 3 : storageClassIndex = 0 ;
26521 3 : if ( 0 < sizeOfActualPool )
26522 : {
26523 0 : SgOmpGrainsizeClauseStorageClass* storageArray = new SgOmpGrainsizeClauseStorageClass[sizeOfActualPool] ;
26524 0 : storageClassIndex = SgOmpGrainsizeClause::initializeStorageClassArray (storageArray); ;
26525 0 : assert ( storageClassIndex == sizeOfActualPool );
26526 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpGrainsizeClauseStorageClass ) * sizeOfActualPool) ;
26527 0 : delete [] storageArray;
26528 0 : SgOmpGrainsizeClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26529 : }
26530 :
26531 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDetachClause );
26532 3 : storageClassIndex = 0 ;
26533 3 : if ( 0 < sizeOfActualPool )
26534 : {
26535 0 : SgOmpDetachClauseStorageClass* storageArray = new SgOmpDetachClauseStorageClass[sizeOfActualPool] ;
26536 0 : storageClassIndex = SgOmpDetachClause::initializeStorageClassArray (storageArray); ;
26537 0 : assert ( storageClassIndex == sizeOfActualPool );
26538 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDetachClauseStorageClass ) * sizeOfActualPool) ;
26539 0 : delete [] storageArray;
26540 0 : SgOmpDetachClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26541 : }
26542 :
26543 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNumTasksClause );
26544 3 : storageClassIndex = 0 ;
26545 3 : if ( 0 < sizeOfActualPool )
26546 : {
26547 0 : SgOmpNumTasksClauseStorageClass* storageArray = new SgOmpNumTasksClauseStorageClass[sizeOfActualPool] ;
26548 0 : storageClassIndex = SgOmpNumTasksClause::initializeStorageClassArray (storageArray); ;
26549 0 : assert ( storageClassIndex == sizeOfActualPool );
26550 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNumTasksClauseStorageClass ) * sizeOfActualPool) ;
26551 0 : delete [] storageArray;
26552 0 : SgOmpNumTasksClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26553 : }
26554 :
26555 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNogroupClause );
26556 3 : storageClassIndex = 0 ;
26557 3 : if ( 0 < sizeOfActualPool )
26558 : {
26559 0 : SgOmpNogroupClauseStorageClass* storageArray = new SgOmpNogroupClauseStorageClass[sizeOfActualPool] ;
26560 0 : storageClassIndex = SgOmpNogroupClause::initializeStorageClassArray (storageArray); ;
26561 0 : assert ( storageClassIndex == sizeOfActualPool );
26562 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNogroupClauseStorageClass ) * sizeOfActualPool) ;
26563 0 : delete [] storageArray;
26564 0 : SgOmpNogroupClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26565 : }
26566 :
26567 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpHintClause );
26568 3 : storageClassIndex = 0 ;
26569 3 : if ( 0 < sizeOfActualPool )
26570 : {
26571 0 : SgOmpHintClauseStorageClass* storageArray = new SgOmpHintClauseStorageClass[sizeOfActualPool] ;
26572 0 : storageClassIndex = SgOmpHintClause::initializeStorageClassArray (storageArray); ;
26573 0 : assert ( storageClassIndex == sizeOfActualPool );
26574 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpHintClauseStorageClass ) * sizeOfActualPool) ;
26575 0 : delete [] storageArray;
26576 0 : SgOmpHintClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26577 : }
26578 :
26579 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpOrderClause );
26580 3 : storageClassIndex = 0 ;
26581 3 : if ( 0 < sizeOfActualPool )
26582 : {
26583 0 : SgOmpOrderClauseStorageClass* storageArray = new SgOmpOrderClauseStorageClass[sizeOfActualPool] ;
26584 0 : storageClassIndex = SgOmpOrderClause::initializeStorageClassArray (storageArray); ;
26585 0 : assert ( storageClassIndex == sizeOfActualPool );
26586 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpOrderClauseStorageClass ) * sizeOfActualPool) ;
26587 0 : delete [] storageArray;
26588 0 : SgOmpOrderClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26589 : }
26590 :
26591 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDistScheduleClause );
26592 3 : storageClassIndex = 0 ;
26593 3 : if ( 0 < sizeOfActualPool )
26594 : {
26595 0 : SgOmpDistScheduleClauseStorageClass* storageArray = new SgOmpDistScheduleClauseStorageClass[sizeOfActualPool] ;
26596 0 : storageClassIndex = SgOmpDistScheduleClause::initializeStorageClassArray (storageArray); ;
26597 0 : assert ( storageClassIndex == sizeOfActualPool );
26598 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDistScheduleClauseStorageClass ) * sizeOfActualPool) ;
26599 0 : delete [] storageArray;
26600 0 : SgOmpDistScheduleClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26601 : }
26602 :
26603 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpBindClause );
26604 3 : storageClassIndex = 0 ;
26605 3 : if ( 0 < sizeOfActualPool )
26606 : {
26607 0 : SgOmpBindClauseStorageClass* storageArray = new SgOmpBindClauseStorageClass[sizeOfActualPool] ;
26608 0 : storageClassIndex = SgOmpBindClause::initializeStorageClassArray (storageArray); ;
26609 0 : assert ( storageClassIndex == sizeOfActualPool );
26610 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpBindClauseStorageClass ) * sizeOfActualPool) ;
26611 0 : delete [] storageArray;
26612 0 : SgOmpBindClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26613 : }
26614 :
26615 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNontemporalClause );
26616 3 : storageClassIndex = 0 ;
26617 3 : if ( 0 < sizeOfActualPool )
26618 : {
26619 0 : SgOmpNontemporalClauseStorageClass* storageArray = new SgOmpNontemporalClauseStorageClass[sizeOfActualPool] ;
26620 0 : storageClassIndex = SgOmpNontemporalClause::initializeStorageClassArray (storageArray); ;
26621 0 : assert ( storageClassIndex == sizeOfActualPool );
26622 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNontemporalClauseStorageClass ) * sizeOfActualPool) ;
26623 0 : delete [] storageArray;
26624 0 : SgOmpNontemporalClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26625 : }
26626 :
26627 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpInclusiveClause );
26628 3 : storageClassIndex = 0 ;
26629 3 : if ( 0 < sizeOfActualPool )
26630 : {
26631 0 : SgOmpInclusiveClauseStorageClass* storageArray = new SgOmpInclusiveClauseStorageClass[sizeOfActualPool] ;
26632 0 : storageClassIndex = SgOmpInclusiveClause::initializeStorageClassArray (storageArray); ;
26633 0 : assert ( storageClassIndex == sizeOfActualPool );
26634 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpInclusiveClauseStorageClass ) * sizeOfActualPool) ;
26635 0 : delete [] storageArray;
26636 0 : SgOmpInclusiveClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26637 : }
26638 :
26639 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpExclusiveClause );
26640 3 : storageClassIndex = 0 ;
26641 3 : if ( 0 < sizeOfActualPool )
26642 : {
26643 0 : SgOmpExclusiveClauseStorageClass* storageArray = new SgOmpExclusiveClauseStorageClass[sizeOfActualPool] ;
26644 0 : storageClassIndex = SgOmpExclusiveClause::initializeStorageClassArray (storageArray); ;
26645 0 : assert ( storageClassIndex == sizeOfActualPool );
26646 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpExclusiveClauseStorageClass ) * sizeOfActualPool) ;
26647 0 : delete [] storageArray;
26648 0 : SgOmpExclusiveClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26649 : }
26650 :
26651 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpIsDevicePtrClause );
26652 3 : storageClassIndex = 0 ;
26653 3 : if ( 0 < sizeOfActualPool )
26654 : {
26655 0 : SgOmpIsDevicePtrClauseStorageClass* storageArray = new SgOmpIsDevicePtrClauseStorageClass[sizeOfActualPool] ;
26656 0 : storageClassIndex = SgOmpIsDevicePtrClause::initializeStorageClassArray (storageArray); ;
26657 0 : assert ( storageClassIndex == sizeOfActualPool );
26658 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpIsDevicePtrClauseStorageClass ) * sizeOfActualPool) ;
26659 0 : delete [] storageArray;
26660 0 : SgOmpIsDevicePtrClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26661 : }
26662 :
26663 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUseDevicePtrClause );
26664 3 : storageClassIndex = 0 ;
26665 3 : if ( 0 < sizeOfActualPool )
26666 : {
26667 0 : SgOmpUseDevicePtrClauseStorageClass* storageArray = new SgOmpUseDevicePtrClauseStorageClass[sizeOfActualPool] ;
26668 0 : storageClassIndex = SgOmpUseDevicePtrClause::initializeStorageClassArray (storageArray); ;
26669 0 : assert ( storageClassIndex == sizeOfActualPool );
26670 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUseDevicePtrClauseStorageClass ) * sizeOfActualPool) ;
26671 0 : delete [] storageArray;
26672 0 : SgOmpUseDevicePtrClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26673 : }
26674 :
26675 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUseDeviceAddrClause );
26676 3 : storageClassIndex = 0 ;
26677 3 : if ( 0 < sizeOfActualPool )
26678 : {
26679 0 : SgOmpUseDeviceAddrClauseStorageClass* storageArray = new SgOmpUseDeviceAddrClauseStorageClass[sizeOfActualPool] ;
26680 0 : storageClassIndex = SgOmpUseDeviceAddrClause::initializeStorageClassArray (storageArray); ;
26681 0 : assert ( storageClassIndex == sizeOfActualPool );
26682 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUseDeviceAddrClauseStorageClass ) * sizeOfActualPool) ;
26683 0 : delete [] storageArray;
26684 0 : SgOmpUseDeviceAddrClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26685 : }
26686 :
26687 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpThreadLimitClause );
26688 3 : storageClassIndex = 0 ;
26689 3 : if ( 0 < sizeOfActualPool )
26690 : {
26691 0 : SgOmpThreadLimitClauseStorageClass* storageArray = new SgOmpThreadLimitClauseStorageClass[sizeOfActualPool] ;
26692 0 : storageClassIndex = SgOmpThreadLimitClause::initializeStorageClassArray (storageArray); ;
26693 0 : assert ( storageClassIndex == sizeOfActualPool );
26694 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpThreadLimitClauseStorageClass ) * sizeOfActualPool) ;
26695 0 : delete [] storageArray;
26696 0 : SgOmpThreadLimitClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26697 : }
26698 :
26699 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpOrderedClause );
26700 3 : storageClassIndex = 0 ;
26701 3 : if ( 0 < sizeOfActualPool )
26702 : {
26703 0 : SgOmpOrderedClauseStorageClass* storageArray = new SgOmpOrderedClauseStorageClass[sizeOfActualPool] ;
26704 0 : storageClassIndex = SgOmpOrderedClause::initializeStorageClassArray (storageArray); ;
26705 0 : assert ( storageClassIndex == sizeOfActualPool );
26706 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpOrderedClauseStorageClass ) * sizeOfActualPool) ;
26707 0 : delete [] storageArray;
26708 0 : SgOmpOrderedClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26709 : }
26710 :
26711 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpPrivateClause );
26712 3 : storageClassIndex = 0 ;
26713 3 : if ( 0 < sizeOfActualPool )
26714 : {
26715 0 : SgOmpPrivateClauseStorageClass* storageArray = new SgOmpPrivateClauseStorageClass[sizeOfActualPool] ;
26716 0 : storageClassIndex = SgOmpPrivateClause::initializeStorageClassArray (storageArray); ;
26717 0 : assert ( storageClassIndex == sizeOfActualPool );
26718 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpPrivateClauseStorageClass ) * sizeOfActualPool) ;
26719 0 : delete [] storageArray;
26720 0 : SgOmpPrivateClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26721 : }
26722 :
26723 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpReductionClause );
26724 3 : storageClassIndex = 0 ;
26725 3 : if ( 0 < sizeOfActualPool )
26726 : {
26727 0 : SgOmpReductionClauseStorageClass* storageArray = new SgOmpReductionClauseStorageClass[sizeOfActualPool] ;
26728 0 : storageClassIndex = SgOmpReductionClause::initializeStorageClassArray (storageArray); ;
26729 0 : assert ( storageClassIndex == sizeOfActualPool );
26730 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpReductionClauseStorageClass ) * sizeOfActualPool) ;
26731 0 : delete [] storageArray;
26732 0 : SgOmpReductionClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26733 : }
26734 :
26735 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpInReductionClause );
26736 3 : storageClassIndex = 0 ;
26737 3 : if ( 0 < sizeOfActualPool )
26738 : {
26739 0 : SgOmpInReductionClauseStorageClass* storageArray = new SgOmpInReductionClauseStorageClass[sizeOfActualPool] ;
26740 0 : storageClassIndex = SgOmpInReductionClause::initializeStorageClassArray (storageArray); ;
26741 0 : assert ( storageClassIndex == sizeOfActualPool );
26742 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpInReductionClauseStorageClass ) * sizeOfActualPool) ;
26743 0 : delete [] storageArray;
26744 0 : SgOmpInReductionClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26745 : }
26746 :
26747 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpTaskReductionClause );
26748 3 : storageClassIndex = 0 ;
26749 3 : if ( 0 < sizeOfActualPool )
26750 : {
26751 0 : SgOmpTaskReductionClauseStorageClass* storageArray = new SgOmpTaskReductionClauseStorageClass[sizeOfActualPool] ;
26752 0 : storageClassIndex = SgOmpTaskReductionClause::initializeStorageClassArray (storageArray); ;
26753 0 : assert ( storageClassIndex == sizeOfActualPool );
26754 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpTaskReductionClauseStorageClass ) * sizeOfActualPool) ;
26755 0 : delete [] storageArray;
26756 0 : SgOmpTaskReductionClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26757 : }
26758 :
26759 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDefaultmapClause );
26760 3 : storageClassIndex = 0 ;
26761 3 : if ( 0 < sizeOfActualPool )
26762 : {
26763 0 : SgOmpDefaultmapClauseStorageClass* storageArray = new SgOmpDefaultmapClauseStorageClass[sizeOfActualPool] ;
26764 0 : storageClassIndex = SgOmpDefaultmapClause::initializeStorageClassArray (storageArray); ;
26765 0 : assert ( storageClassIndex == sizeOfActualPool );
26766 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDefaultmapClauseStorageClass ) * sizeOfActualPool) ;
26767 0 : delete [] storageArray;
26768 0 : SgOmpDefaultmapClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26769 : }
26770 :
26771 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpScheduleClause );
26772 3 : storageClassIndex = 0 ;
26773 3 : if ( 0 < sizeOfActualPool )
26774 : {
26775 0 : SgOmpScheduleClauseStorageClass* storageArray = new SgOmpScheduleClauseStorageClass[sizeOfActualPool] ;
26776 0 : storageClassIndex = SgOmpScheduleClause::initializeStorageClassArray (storageArray); ;
26777 0 : assert ( storageClassIndex == sizeOfActualPool );
26778 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpScheduleClauseStorageClass ) * sizeOfActualPool) ;
26779 0 : delete [] storageArray;
26780 0 : SgOmpScheduleClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26781 : }
26782 :
26783 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSharedClause );
26784 3 : storageClassIndex = 0 ;
26785 3 : if ( 0 < sizeOfActualPool )
26786 : {
26787 0 : SgOmpSharedClauseStorageClass* storageArray = new SgOmpSharedClauseStorageClass[sizeOfActualPool] ;
26788 0 : storageClassIndex = SgOmpSharedClause::initializeStorageClassArray (storageArray); ;
26789 0 : assert ( storageClassIndex == sizeOfActualPool );
26790 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSharedClauseStorageClass ) * sizeOfActualPool) ;
26791 0 : delete [] storageArray;
26792 0 : SgOmpSharedClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26793 : }
26794 :
26795 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUntiedClause );
26796 3 : storageClassIndex = 0 ;
26797 3 : if ( 0 < sizeOfActualPool )
26798 : {
26799 0 : SgOmpUntiedClauseStorageClass* storageArray = new SgOmpUntiedClauseStorageClass[sizeOfActualPool] ;
26800 0 : storageClassIndex = SgOmpUntiedClause::initializeStorageClassArray (storageArray); ;
26801 0 : assert ( storageClassIndex == sizeOfActualPool );
26802 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUntiedClauseStorageClass ) * sizeOfActualPool) ;
26803 0 : delete [] storageArray;
26804 0 : SgOmpUntiedClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26805 : }
26806 :
26807 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMergeableClause );
26808 3 : storageClassIndex = 0 ;
26809 3 : if ( 0 < sizeOfActualPool )
26810 : {
26811 0 : SgOmpMergeableClauseStorageClass* storageArray = new SgOmpMergeableClauseStorageClass[sizeOfActualPool] ;
26812 0 : storageClassIndex = SgOmpMergeableClause::initializeStorageClassArray (storageArray); ;
26813 0 : assert ( storageClassIndex == sizeOfActualPool );
26814 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMergeableClauseStorageClass ) * sizeOfActualPool) ;
26815 0 : delete [] storageArray;
26816 0 : SgOmpMergeableClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26817 : }
26818 :
26819 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpVariablesClause );
26820 3 : storageClassIndex = 0 ;
26821 3 : if ( 0 < sizeOfActualPool )
26822 : {
26823 0 : SgOmpVariablesClauseStorageClass* storageArray = new SgOmpVariablesClauseStorageClass[sizeOfActualPool] ;
26824 0 : storageClassIndex = SgOmpVariablesClause::initializeStorageClassArray (storageArray); ;
26825 0 : assert ( storageClassIndex == sizeOfActualPool );
26826 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpVariablesClauseStorageClass ) * sizeOfActualPool) ;
26827 0 : delete [] storageArray;
26828 0 : SgOmpVariablesClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26829 : }
26830 :
26831 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpMapClause );
26832 3 : storageClassIndex = 0 ;
26833 3 : if ( 0 < sizeOfActualPool )
26834 : {
26835 0 : SgOmpMapClauseStorageClass* storageArray = new SgOmpMapClauseStorageClass[sizeOfActualPool] ;
26836 0 : storageClassIndex = SgOmpMapClause::initializeStorageClassArray (storageArray); ;
26837 0 : assert ( storageClassIndex == sizeOfActualPool );
26838 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpMapClauseStorageClass ) * sizeOfActualPool) ;
26839 0 : delete [] storageArray;
26840 0 : SgOmpMapClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26841 : }
26842 :
26843 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSafelenClause );
26844 3 : storageClassIndex = 0 ;
26845 3 : if ( 0 < sizeOfActualPool )
26846 : {
26847 0 : SgOmpSafelenClauseStorageClass* storageArray = new SgOmpSafelenClauseStorageClass[sizeOfActualPool] ;
26848 0 : storageClassIndex = SgOmpSafelenClause::initializeStorageClassArray (storageArray); ;
26849 0 : assert ( storageClassIndex == sizeOfActualPool );
26850 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSafelenClauseStorageClass ) * sizeOfActualPool) ;
26851 0 : delete [] storageArray;
26852 0 : SgOmpSafelenClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26853 : }
26854 :
26855 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSimdlenClause );
26856 3 : storageClassIndex = 0 ;
26857 3 : if ( 0 < sizeOfActualPool )
26858 : {
26859 0 : SgOmpSimdlenClauseStorageClass* storageArray = new SgOmpSimdlenClauseStorageClass[sizeOfActualPool] ;
26860 0 : storageClassIndex = SgOmpSimdlenClause::initializeStorageClassArray (storageArray); ;
26861 0 : assert ( storageClassIndex == sizeOfActualPool );
26862 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSimdlenClauseStorageClass ) * sizeOfActualPool) ;
26863 0 : delete [] storageArray;
26864 0 : SgOmpSimdlenClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26865 : }
26866 :
26867 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpLinearClause );
26868 3 : storageClassIndex = 0 ;
26869 3 : if ( 0 < sizeOfActualPool )
26870 : {
26871 0 : SgOmpLinearClauseStorageClass* storageArray = new SgOmpLinearClauseStorageClass[sizeOfActualPool] ;
26872 0 : storageClassIndex = SgOmpLinearClause::initializeStorageClassArray (storageArray); ;
26873 0 : assert ( storageClassIndex == sizeOfActualPool );
26874 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpLinearClauseStorageClass ) * sizeOfActualPool) ;
26875 0 : delete [] storageArray;
26876 0 : SgOmpLinearClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26877 : }
26878 :
26879 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpUniformClause );
26880 3 : storageClassIndex = 0 ;
26881 3 : if ( 0 < sizeOfActualPool )
26882 : {
26883 0 : SgOmpUniformClauseStorageClass* storageArray = new SgOmpUniformClauseStorageClass[sizeOfActualPool] ;
26884 0 : storageClassIndex = SgOmpUniformClause::initializeStorageClassArray (storageArray); ;
26885 0 : assert ( storageClassIndex == sizeOfActualPool );
26886 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpUniformClauseStorageClass ) * sizeOfActualPool) ;
26887 0 : delete [] storageArray;
26888 0 : SgOmpUniformClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26889 : }
26890 :
26891 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAlignedClause );
26892 3 : storageClassIndex = 0 ;
26893 3 : if ( 0 < sizeOfActualPool )
26894 : {
26895 0 : SgOmpAlignedClauseStorageClass* storageArray = new SgOmpAlignedClauseStorageClass[sizeOfActualPool] ;
26896 0 : storageClassIndex = SgOmpAlignedClause::initializeStorageClassArray (storageArray); ;
26897 0 : assert ( storageClassIndex == sizeOfActualPool );
26898 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAlignedClauseStorageClass ) * sizeOfActualPool) ;
26899 0 : delete [] storageArray;
26900 0 : SgOmpAlignedClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26901 : }
26902 :
26903 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpProcBindClause );
26904 3 : storageClassIndex = 0 ;
26905 3 : if ( 0 < sizeOfActualPool )
26906 : {
26907 0 : SgOmpProcBindClauseStorageClass* storageArray = new SgOmpProcBindClauseStorageClass[sizeOfActualPool] ;
26908 0 : storageClassIndex = SgOmpProcBindClause::initializeStorageClassArray (storageArray); ;
26909 0 : assert ( storageClassIndex == sizeOfActualPool );
26910 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpProcBindClauseStorageClass ) * sizeOfActualPool) ;
26911 0 : delete [] storageArray;
26912 0 : SgOmpProcBindClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26913 : }
26914 :
26915 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAtomicClause );
26916 3 : storageClassIndex = 0 ;
26917 3 : if ( 0 < sizeOfActualPool )
26918 : {
26919 0 : SgOmpAtomicClauseStorageClass* storageArray = new SgOmpAtomicClauseStorageClass[sizeOfActualPool] ;
26920 0 : storageClassIndex = SgOmpAtomicClause::initializeStorageClassArray (storageArray); ;
26921 0 : assert ( storageClassIndex == sizeOfActualPool );
26922 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAtomicClauseStorageClass ) * sizeOfActualPool) ;
26923 0 : delete [] storageArray;
26924 0 : SgOmpAtomicClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26925 : }
26926 :
26927 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpInbranchClause );
26928 3 : storageClassIndex = 0 ;
26929 3 : if ( 0 < sizeOfActualPool )
26930 : {
26931 0 : SgOmpInbranchClauseStorageClass* storageArray = new SgOmpInbranchClauseStorageClass[sizeOfActualPool] ;
26932 0 : storageClassIndex = SgOmpInbranchClause::initializeStorageClassArray (storageArray); ;
26933 0 : assert ( storageClassIndex == sizeOfActualPool );
26934 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpInbranchClauseStorageClass ) * sizeOfActualPool) ;
26935 0 : delete [] storageArray;
26936 0 : SgOmpInbranchClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26937 : }
26938 :
26939 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpNotinbranchClause );
26940 3 : storageClassIndex = 0 ;
26941 3 : if ( 0 < sizeOfActualPool )
26942 : {
26943 0 : SgOmpNotinbranchClauseStorageClass* storageArray = new SgOmpNotinbranchClauseStorageClass[sizeOfActualPool] ;
26944 0 : storageClassIndex = SgOmpNotinbranchClause::initializeStorageClassArray (storageArray); ;
26945 0 : assert ( storageClassIndex == sizeOfActualPool );
26946 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpNotinbranchClauseStorageClass ) * sizeOfActualPool) ;
26947 0 : delete [] storageArray;
26948 0 : SgOmpNotinbranchClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26949 : }
26950 :
26951 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpDependClause );
26952 3 : storageClassIndex = 0 ;
26953 3 : if ( 0 < sizeOfActualPool )
26954 : {
26955 0 : SgOmpDependClauseStorageClass* storageArray = new SgOmpDependClauseStorageClass[sizeOfActualPool] ;
26956 0 : storageClassIndex = SgOmpDependClause::initializeStorageClassArray (storageArray); ;
26957 0 : assert ( storageClassIndex == sizeOfActualPool );
26958 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpDependClauseStorageClass ) * sizeOfActualPool) ;
26959 0 : delete [] storageArray;
26960 0 : SgOmpDependClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26961 : }
26962 :
26963 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpAffinityClause );
26964 3 : storageClassIndex = 0 ;
26965 3 : if ( 0 < sizeOfActualPool )
26966 : {
26967 0 : SgOmpAffinityClauseStorageClass* storageArray = new SgOmpAffinityClauseStorageClass[sizeOfActualPool] ;
26968 0 : storageClassIndex = SgOmpAffinityClause::initializeStorageClassArray (storageArray); ;
26969 0 : assert ( storageClassIndex == sizeOfActualPool );
26970 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpAffinityClauseStorageClass ) * sizeOfActualPool) ;
26971 0 : delete [] storageArray;
26972 0 : SgOmpAffinityClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26973 : }
26974 :
26975 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpWhenClause );
26976 3 : storageClassIndex = 0 ;
26977 3 : if ( 0 < sizeOfActualPool )
26978 : {
26979 0 : SgOmpWhenClauseStorageClass* storageArray = new SgOmpWhenClauseStorageClass[sizeOfActualPool] ;
26980 0 : storageClassIndex = SgOmpWhenClause::initializeStorageClassArray (storageArray); ;
26981 0 : assert ( storageClassIndex == sizeOfActualPool );
26982 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpWhenClauseStorageClass ) * sizeOfActualPool) ;
26983 0 : delete [] storageArray;
26984 0 : SgOmpWhenClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26985 : }
26986 :
26987 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpFullClause );
26988 3 : storageClassIndex = 0 ;
26989 3 : if ( 0 < sizeOfActualPool )
26990 : {
26991 0 : SgOmpFullClauseStorageClass* storageArray = new SgOmpFullClauseStorageClass[sizeOfActualPool] ;
26992 0 : storageClassIndex = SgOmpFullClause::initializeStorageClassArray (storageArray); ;
26993 0 : assert ( storageClassIndex == sizeOfActualPool );
26994 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpFullClauseStorageClass ) * sizeOfActualPool) ;
26995 0 : delete [] storageArray;
26996 0 : SgOmpFullClauseStorageClass :: writeEasyStorageDataToFile(out) ;
26997 : }
26998 :
26999 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpPartialClause );
27000 3 : storageClassIndex = 0 ;
27001 3 : if ( 0 < sizeOfActualPool )
27002 : {
27003 0 : SgOmpPartialClauseStorageClass* storageArray = new SgOmpPartialClauseStorageClass[sizeOfActualPool] ;
27004 0 : storageClassIndex = SgOmpPartialClause::initializeStorageClassArray (storageArray); ;
27005 0 : assert ( storageClassIndex == sizeOfActualPool );
27006 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpPartialClauseStorageClass ) * sizeOfActualPool) ;
27007 0 : delete [] storageArray;
27008 0 : SgOmpPartialClauseStorageClass :: writeEasyStorageDataToFile(out) ;
27009 : }
27010 :
27011 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOmpSizesClause );
27012 3 : storageClassIndex = 0 ;
27013 3 : if ( 0 < sizeOfActualPool )
27014 : {
27015 0 : SgOmpSizesClauseStorageClass* storageArray = new SgOmpSizesClauseStorageClass[sizeOfActualPool] ;
27016 0 : storageClassIndex = SgOmpSizesClause::initializeStorageClassArray (storageArray); ;
27017 0 : assert ( storageClassIndex == sizeOfActualPool );
27018 0 : out.write ( (char*) (storageArray) , sizeof ( SgOmpSizesClauseStorageClass ) * sizeOfActualPool) ;
27019 0 : delete [] storageArray;
27020 0 : SgOmpSizesClauseStorageClass :: writeEasyStorageDataToFile(out) ;
27021 : }
27022 :
27023 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirBranchField );
27024 3 : storageClassIndex = 0 ;
27025 3 : if ( 0 < sizeOfActualPool )
27026 : {
27027 0 : SgUpirBranchFieldStorageClass* storageArray = new SgUpirBranchFieldStorageClass[sizeOfActualPool] ;
27028 0 : storageClassIndex = SgUpirBranchField::initializeStorageClassArray (storageArray); ;
27029 0 : assert ( storageClassIndex == sizeOfActualPool );
27030 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirBranchFieldStorageClass ) * sizeOfActualPool) ;
27031 0 : delete [] storageArray;
27032 0 : SgUpirBranchFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27033 : }
27034 :
27035 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirNestedLevelField );
27036 3 : storageClassIndex = 0 ;
27037 3 : if ( 0 < sizeOfActualPool )
27038 : {
27039 0 : SgUpirNestedLevelFieldStorageClass* storageArray = new SgUpirNestedLevelFieldStorageClass[sizeOfActualPool] ;
27040 0 : storageClassIndex = SgUpirNestedLevelField::initializeStorageClassArray (storageArray); ;
27041 0 : assert ( storageClassIndex == sizeOfActualPool );
27042 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirNestedLevelFieldStorageClass ) * sizeOfActualPool) ;
27043 0 : delete [] storageArray;
27044 0 : SgUpirNestedLevelFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27045 : }
27046 :
27047 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirNestedParentField );
27048 3 : storageClassIndex = 0 ;
27049 3 : if ( 0 < sizeOfActualPool )
27050 : {
27051 0 : SgUpirNestedParentFieldStorageClass* storageArray = new SgUpirNestedParentFieldStorageClass[sizeOfActualPool] ;
27052 0 : storageClassIndex = SgUpirNestedParentField::initializeStorageClassArray (storageArray); ;
27053 0 : assert ( storageClassIndex == sizeOfActualPool );
27054 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirNestedParentFieldStorageClass ) * sizeOfActualPool) ;
27055 0 : delete [] storageArray;
27056 0 : SgUpirNestedParentFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27057 : }
27058 :
27059 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirNestedChildField );
27060 3 : storageClassIndex = 0 ;
27061 3 : if ( 0 < sizeOfActualPool )
27062 : {
27063 0 : SgUpirNestedChildFieldStorageClass* storageArray = new SgUpirNestedChildFieldStorageClass[sizeOfActualPool] ;
27064 0 : storageClassIndex = SgUpirNestedChildField::initializeStorageClassArray (storageArray); ;
27065 0 : assert ( storageClassIndex == sizeOfActualPool );
27066 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirNestedChildFieldStorageClass ) * sizeOfActualPool) ;
27067 0 : delete [] storageArray;
27068 0 : SgUpirNestedChildFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27069 : }
27070 :
27071 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirSyncField );
27072 3 : storageClassIndex = 0 ;
27073 3 : if ( 0 < sizeOfActualPool )
27074 : {
27075 0 : SgUpirSyncFieldStorageClass* storageArray = new SgUpirSyncFieldStorageClass[sizeOfActualPool] ;
27076 0 : storageClassIndex = SgUpirSyncField::initializeStorageClassArray (storageArray); ;
27077 0 : assert ( storageClassIndex == sizeOfActualPool );
27078 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirSyncFieldStorageClass ) * sizeOfActualPool) ;
27079 0 : delete [] storageArray;
27080 0 : SgUpirSyncFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27081 : }
27082 :
27083 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirDataField );
27084 3 : storageClassIndex = 0 ;
27085 3 : if ( 0 < sizeOfActualPool )
27086 : {
27087 0 : SgUpirDataFieldStorageClass* storageArray = new SgUpirDataFieldStorageClass[sizeOfActualPool] ;
27088 0 : storageClassIndex = SgUpirDataField::initializeStorageClassArray (storageArray); ;
27089 0 : assert ( storageClassIndex == sizeOfActualPool );
27090 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirDataFieldStorageClass ) * sizeOfActualPool) ;
27091 0 : delete [] storageArray;
27092 0 : SgUpirDataFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27093 : }
27094 :
27095 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirDataItemField );
27096 3 : storageClassIndex = 0 ;
27097 3 : if ( 0 < sizeOfActualPool )
27098 : {
27099 0 : SgUpirDataItemFieldStorageClass* storageArray = new SgUpirDataItemFieldStorageClass[sizeOfActualPool] ;
27100 0 : storageClassIndex = SgUpirDataItemField::initializeStorageClassArray (storageArray); ;
27101 0 : assert ( storageClassIndex == sizeOfActualPool );
27102 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirDataItemFieldStorageClass ) * sizeOfActualPool) ;
27103 0 : delete [] storageArray;
27104 0 : SgUpirDataItemFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27105 : }
27106 :
27107 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpirTargetField );
27108 3 : storageClassIndex = 0 ;
27109 3 : if ( 0 < sizeOfActualPool )
27110 : {
27111 0 : SgUpirTargetFieldStorageClass* storageArray = new SgUpirTargetFieldStorageClass[sizeOfActualPool] ;
27112 0 : storageClassIndex = SgUpirTargetField::initializeStorageClassArray (storageArray); ;
27113 0 : assert ( storageClassIndex == sizeOfActualPool );
27114 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpirTargetFieldStorageClass ) * sizeOfActualPool) ;
27115 0 : delete [] storageArray;
27116 0 : SgUpirTargetFieldStorageClass :: writeEasyStorageDataToFile(out) ;
27117 : }
27118 :
27119 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOpenclAccessModeModifier );
27120 3 : storageClassIndex = 0 ;
27121 3 : if ( 0 < sizeOfActualPool )
27122 : {
27123 0 : SgOpenclAccessModeModifierStorageClass* storageArray = new SgOpenclAccessModeModifierStorageClass[sizeOfActualPool] ;
27124 0 : storageClassIndex = SgOpenclAccessModeModifier::initializeStorageClassArray (storageArray); ;
27125 0 : assert ( storageClassIndex == sizeOfActualPool );
27126 0 : out.write ( (char*) (storageArray) , sizeof ( SgOpenclAccessModeModifierStorageClass ) * sizeOfActualPool) ;
27127 0 : delete [] storageArray;
27128 : }
27129 :
27130 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOpenStatement );
27131 3 : storageClassIndex = 0 ;
27132 3 : if ( 0 < sizeOfActualPool )
27133 : {
27134 0 : SgOpenStatementStorageClass* storageArray = new SgOpenStatementStorageClass[sizeOfActualPool] ;
27135 0 : storageClassIndex = SgOpenStatement::initializeStorageClassArray (storageArray); ;
27136 0 : assert ( storageClassIndex == sizeOfActualPool );
27137 0 : out.write ( (char*) (storageArray) , sizeof ( SgOpenStatementStorageClass ) * sizeOfActualPool) ;
27138 0 : delete [] storageArray;
27139 0 : SgOpenStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27140 : }
27141 :
27142 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOptions );
27143 3 : storageClassIndex = 0 ;
27144 3 : if ( 0 < sizeOfActualPool )
27145 : {
27146 0 : SgOptionsStorageClass* storageArray = new SgOptionsStorageClass[sizeOfActualPool] ;
27147 0 : storageClassIndex = SgOptions::initializeStorageClassArray (storageArray); ;
27148 0 : assert ( storageClassIndex == sizeOfActualPool );
27149 0 : out.write ( (char*) (storageArray) , sizeof ( SgOptionsStorageClass ) * sizeOfActualPool) ;
27150 0 : delete [] storageArray;
27151 : }
27152 :
27153 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgOrOp );
27154 3 : storageClassIndex = 0 ;
27155 3 : if ( 0 < sizeOfActualPool )
27156 : {
27157 84 : SgOrOpStorageClass* storageArray = new SgOrOpStorageClass[sizeOfActualPool] ;
27158 1 : storageClassIndex = SgOrOp::initializeStorageClassArray (storageArray); ;
27159 1 : assert ( storageClassIndex == sizeOfActualPool );
27160 1 : out.write ( (char*) (storageArray) , sizeof ( SgOrOpStorageClass ) * sizeOfActualPool) ;
27161 1 : delete [] storageArray;
27162 1 : SgOrOpStorageClass :: writeEasyStorageDataToFile(out) ;
27163 : }
27164 :
27165 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgParameterStatement );
27166 3 : storageClassIndex = 0 ;
27167 3 : if ( 0 < sizeOfActualPool )
27168 : {
27169 0 : SgParameterStatementStorageClass* storageArray = new SgParameterStatementStorageClass[sizeOfActualPool] ;
27170 0 : storageClassIndex = SgParameterStatement::initializeStorageClassArray (storageArray); ;
27171 0 : assert ( storageClassIndex == sizeOfActualPool );
27172 0 : out.write ( (char*) (storageArray) , sizeof ( SgParameterStatementStorageClass ) * sizeOfActualPool) ;
27173 0 : delete [] storageArray;
27174 0 : SgParameterStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27175 : }
27176 :
27177 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPartialFunctionModifierType );
27178 3 : storageClassIndex = 0 ;
27179 3 : if ( 0 < sizeOfActualPool )
27180 : {
27181 0 : SgPartialFunctionModifierTypeStorageClass* storageArray = new SgPartialFunctionModifierTypeStorageClass[sizeOfActualPool] ;
27182 0 : storageClassIndex = SgPartialFunctionModifierType::initializeStorageClassArray (storageArray); ;
27183 0 : assert ( storageClassIndex == sizeOfActualPool );
27184 0 : out.write ( (char*) (storageArray) , sizeof ( SgPartialFunctionModifierTypeStorageClass ) * sizeOfActualPool) ;
27185 0 : delete [] storageArray;
27186 0 : SgPartialFunctionModifierTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27187 : }
27188 :
27189 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPartialFunctionType );
27190 3 : storageClassIndex = 0 ;
27191 3 : if ( 0 < sizeOfActualPool )
27192 : {
27193 0 : SgPartialFunctionTypeStorageClass* storageArray = new SgPartialFunctionTypeStorageClass[sizeOfActualPool] ;
27194 0 : storageClassIndex = SgPartialFunctionType::initializeStorageClassArray (storageArray); ;
27195 0 : assert ( storageClassIndex == sizeOfActualPool );
27196 0 : out.write ( (char*) (storageArray) , sizeof ( SgPartialFunctionTypeStorageClass ) * sizeOfActualPool) ;
27197 0 : delete [] storageArray;
27198 0 : SgPartialFunctionTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27199 : }
27200 :
27201 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPassStatement );
27202 3 : storageClassIndex = 0 ;
27203 3 : if ( 0 < sizeOfActualPool )
27204 : {
27205 0 : SgPassStatementStorageClass* storageArray = new SgPassStatementStorageClass[sizeOfActualPool] ;
27206 0 : storageClassIndex = SgPassStatement::initializeStorageClassArray (storageArray); ;
27207 0 : assert ( storageClassIndex == sizeOfActualPool );
27208 0 : out.write ( (char*) (storageArray) , sizeof ( SgPassStatementStorageClass ) * sizeOfActualPool) ;
27209 0 : delete [] storageArray;
27210 0 : SgPassStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27211 : }
27212 :
27213 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPlusAssignOp );
27214 3 : storageClassIndex = 0 ;
27215 3 : if ( 0 < sizeOfActualPool )
27216 : {
27217 30 : SgPlusAssignOpStorageClass* storageArray = new SgPlusAssignOpStorageClass[sizeOfActualPool] ;
27218 1 : storageClassIndex = SgPlusAssignOp::initializeStorageClassArray (storageArray); ;
27219 1 : assert ( storageClassIndex == sizeOfActualPool );
27220 1 : out.write ( (char*) (storageArray) , sizeof ( SgPlusAssignOpStorageClass ) * sizeOfActualPool) ;
27221 1 : delete [] storageArray;
27222 1 : SgPlusAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
27223 : }
27224 :
27225 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPlusPlusOp );
27226 3 : storageClassIndex = 0 ;
27227 3 : if ( 0 < sizeOfActualPool )
27228 : {
27229 132 : SgPlusPlusOpStorageClass* storageArray = new SgPlusPlusOpStorageClass[sizeOfActualPool] ;
27230 1 : storageClassIndex = SgPlusPlusOp::initializeStorageClassArray (storageArray); ;
27231 1 : assert ( storageClassIndex == sizeOfActualPool );
27232 1 : out.write ( (char*) (storageArray) , sizeof ( SgPlusPlusOpStorageClass ) * sizeOfActualPool) ;
27233 1 : delete [] storageArray;
27234 1 : SgPlusPlusOpStorageClass :: writeEasyStorageDataToFile(out) ;
27235 : }
27236 :
27237 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPntrArrRefExp );
27238 3 : storageClassIndex = 0 ;
27239 3 : if ( 0 < sizeOfActualPool )
27240 : {
27241 127 : SgPntrArrRefExpStorageClass* storageArray = new SgPntrArrRefExpStorageClass[sizeOfActualPool] ;
27242 1 : storageClassIndex = SgPntrArrRefExp::initializeStorageClassArray (storageArray); ;
27243 1 : assert ( storageClassIndex == sizeOfActualPool );
27244 1 : out.write ( (char*) (storageArray) , sizeof ( SgPntrArrRefExpStorageClass ) * sizeOfActualPool) ;
27245 1 : delete [] storageArray;
27246 1 : SgPntrArrRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
27247 : }
27248 :
27249 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPointerAssignOp );
27250 3 : storageClassIndex = 0 ;
27251 3 : if ( 0 < sizeOfActualPool )
27252 : {
27253 0 : SgPointerAssignOpStorageClass* storageArray = new SgPointerAssignOpStorageClass[sizeOfActualPool] ;
27254 0 : storageClassIndex = SgPointerAssignOp::initializeStorageClassArray (storageArray); ;
27255 0 : assert ( storageClassIndex == sizeOfActualPool );
27256 0 : out.write ( (char*) (storageArray) , sizeof ( SgPointerAssignOpStorageClass ) * sizeOfActualPool) ;
27257 0 : delete [] storageArray;
27258 0 : SgPointerAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
27259 : }
27260 :
27261 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPointerDerefExp );
27262 3 : storageClassIndex = 0 ;
27263 3 : if ( 0 < sizeOfActualPool )
27264 : {
27265 385 : SgPointerDerefExpStorageClass* storageArray = new SgPointerDerefExpStorageClass[sizeOfActualPool] ;
27266 1 : storageClassIndex = SgPointerDerefExp::initializeStorageClassArray (storageArray); ;
27267 1 : assert ( storageClassIndex == sizeOfActualPool );
27268 1 : out.write ( (char*) (storageArray) , sizeof ( SgPointerDerefExpStorageClass ) * sizeOfActualPool) ;
27269 1 : delete [] storageArray;
27270 1 : SgPointerDerefExpStorageClass :: writeEasyStorageDataToFile(out) ;
27271 : }
27272 :
27273 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPointerMemberType );
27274 3 : storageClassIndex = 0 ;
27275 3 : if ( 0 < sizeOfActualPool )
27276 : {
27277 30 : SgPointerMemberTypeStorageClass* storageArray = new SgPointerMemberTypeStorageClass[sizeOfActualPool] ;
27278 1 : storageClassIndex = SgPointerMemberType::initializeStorageClassArray (storageArray); ;
27279 1 : assert ( storageClassIndex == sizeOfActualPool );
27280 1 : out.write ( (char*) (storageArray) , sizeof ( SgPointerMemberTypeStorageClass ) * sizeOfActualPool) ;
27281 1 : delete [] storageArray;
27282 1 : SgPointerMemberTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27283 : }
27284 :
27285 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPointerType );
27286 3 : storageClassIndex = 0 ;
27287 3 : if ( 0 < sizeOfActualPool )
27288 : {
27289 628 : SgPointerTypeStorageClass* storageArray = new SgPointerTypeStorageClass[sizeOfActualPool] ;
27290 2 : storageClassIndex = SgPointerType::initializeStorageClassArray (storageArray); ;
27291 2 : assert ( storageClassIndex == sizeOfActualPool );
27292 2 : out.write ( (char*) (storageArray) , sizeof ( SgPointerTypeStorageClass ) * sizeOfActualPool) ;
27293 2 : delete [] storageArray;
27294 2 : SgPointerTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27295 : }
27296 :
27297 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPowerOp );
27298 3 : storageClassIndex = 0 ;
27299 3 : if ( 0 < sizeOfActualPool )
27300 : {
27301 0 : SgPowerOpStorageClass* storageArray = new SgPowerOpStorageClass[sizeOfActualPool] ;
27302 0 : storageClassIndex = SgPowerOp::initializeStorageClassArray (storageArray); ;
27303 0 : assert ( storageClassIndex == sizeOfActualPool );
27304 0 : out.write ( (char*) (storageArray) , sizeof ( SgPowerOpStorageClass ) * sizeOfActualPool) ;
27305 0 : delete [] storageArray;
27306 0 : SgPowerOpStorageClass :: writeEasyStorageDataToFile(out) ;
27307 : }
27308 :
27309 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPragma );
27310 3 : storageClassIndex = 0 ;
27311 3 : if ( 0 < sizeOfActualPool )
27312 : {
27313 98 : SgPragmaStorageClass* storageArray = new SgPragmaStorageClass[sizeOfActualPool] ;
27314 1 : storageClassIndex = SgPragma::initializeStorageClassArray (storageArray); ;
27315 1 : assert ( storageClassIndex == sizeOfActualPool );
27316 1 : out.write ( (char*) (storageArray) , sizeof ( SgPragmaStorageClass ) * sizeOfActualPool) ;
27317 1 : delete [] storageArray;
27318 1 : SgPragmaStorageClass :: writeEasyStorageDataToFile(out) ;
27319 : }
27320 :
27321 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPragmaDeclaration );
27322 3 : storageClassIndex = 0 ;
27323 3 : if ( 0 < sizeOfActualPool )
27324 : {
27325 98 : SgPragmaDeclarationStorageClass* storageArray = new SgPragmaDeclarationStorageClass[sizeOfActualPool] ;
27326 1 : storageClassIndex = SgPragmaDeclaration::initializeStorageClassArray (storageArray); ;
27327 1 : assert ( storageClassIndex == sizeOfActualPool );
27328 1 : out.write ( (char*) (storageArray) , sizeof ( SgPragmaDeclarationStorageClass ) * sizeOfActualPool) ;
27329 1 : delete [] storageArray;
27330 1 : SgPragmaDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
27331 : }
27332 :
27333 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPrintStatement );
27334 3 : storageClassIndex = 0 ;
27335 3 : if ( 0 < sizeOfActualPool )
27336 : {
27337 2 : SgPrintStatementStorageClass* storageArray = new SgPrintStatementStorageClass[sizeOfActualPool] ;
27338 1 : storageClassIndex = SgPrintStatement::initializeStorageClassArray (storageArray); ;
27339 1 : assert ( storageClassIndex == sizeOfActualPool );
27340 1 : out.write ( (char*) (storageArray) , sizeof ( SgPrintStatementStorageClass ) * sizeOfActualPool) ;
27341 1 : delete [] storageArray;
27342 1 : SgPrintStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27343 : }
27344 :
27345 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgProcedureHeaderStatement );
27346 3 : storageClassIndex = 0 ;
27347 3 : if ( 0 < sizeOfActualPool )
27348 : {
27349 0 : SgProcedureHeaderStatementStorageClass* storageArray = new SgProcedureHeaderStatementStorageClass[sizeOfActualPool] ;
27350 0 : storageClassIndex = SgProcedureHeaderStatement::initializeStorageClassArray (storageArray); ;
27351 0 : assert ( storageClassIndex == sizeOfActualPool );
27352 0 : out.write ( (char*) (storageArray) , sizeof ( SgProcedureHeaderStatementStorageClass ) * sizeOfActualPool) ;
27353 0 : delete [] storageArray;
27354 0 : SgProcedureHeaderStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27355 : }
27356 :
27357 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgProgramHeaderStatement );
27358 3 : storageClassIndex = 0 ;
27359 3 : if ( 0 < sizeOfActualPool )
27360 : {
27361 2 : SgProgramHeaderStatementStorageClass* storageArray = new SgProgramHeaderStatementStorageClass[sizeOfActualPool] ;
27362 1 : storageClassIndex = SgProgramHeaderStatement::initializeStorageClassArray (storageArray); ;
27363 1 : assert ( storageClassIndex == sizeOfActualPool );
27364 1 : out.write ( (char*) (storageArray) , sizeof ( SgProgramHeaderStatementStorageClass ) * sizeOfActualPool) ;
27365 1 : delete [] storageArray;
27366 1 : SgProgramHeaderStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27367 : }
27368 :
27369 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgProject );
27370 3 : storageClassIndex = 0 ;
27371 3 : if ( 0 < sizeOfActualPool )
27372 : {
27373 6 : SgProjectStorageClass* storageArray = new SgProjectStorageClass[sizeOfActualPool] ;
27374 3 : storageClassIndex = SgProject::initializeStorageClassArray (storageArray); ;
27375 3 : assert ( storageClassIndex == sizeOfActualPool );
27376 3 : out.write ( (char*) (storageArray) , sizeof ( SgProjectStorageClass ) * sizeOfActualPool) ;
27377 3 : delete [] storageArray;
27378 3 : SgProjectStorageClass :: writeEasyStorageDataToFile(out) ;
27379 : }
27380 :
27381 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgPseudoDestructorRefExp );
27382 3 : storageClassIndex = 0 ;
27383 3 : if ( 0 < sizeOfActualPool )
27384 : {
27385 0 : SgPseudoDestructorRefExpStorageClass* storageArray = new SgPseudoDestructorRefExpStorageClass[sizeOfActualPool] ;
27386 0 : storageClassIndex = SgPseudoDestructorRefExp::initializeStorageClassArray (storageArray); ;
27387 0 : assert ( storageClassIndex == sizeOfActualPool );
27388 0 : out.write ( (char*) (storageArray) , sizeof ( SgPseudoDestructorRefExpStorageClass ) * sizeOfActualPool) ;
27389 0 : delete [] storageArray;
27390 0 : SgPseudoDestructorRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
27391 : }
27392 :
27393 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgQualifiedName );
27394 3 : storageClassIndex = 0 ;
27395 3 : if ( 0 < sizeOfActualPool )
27396 : {
27397 0 : SgQualifiedNameStorageClass* storageArray = new SgQualifiedNameStorageClass[sizeOfActualPool] ;
27398 0 : storageClassIndex = SgQualifiedName::initializeStorageClassArray (storageArray); ;
27399 0 : assert ( storageClassIndex == sizeOfActualPool );
27400 0 : out.write ( (char*) (storageArray) , sizeof ( SgQualifiedNameStorageClass ) * sizeOfActualPool) ;
27401 0 : delete [] storageArray;
27402 : }
27403 :
27404 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgQualifiedNameType );
27405 3 : storageClassIndex = 0 ;
27406 3 : if ( 0 < sizeOfActualPool )
27407 : {
27408 0 : SgQualifiedNameTypeStorageClass* storageArray = new SgQualifiedNameTypeStorageClass[sizeOfActualPool] ;
27409 0 : storageClassIndex = SgQualifiedNameType::initializeStorageClassArray (storageArray); ;
27410 0 : assert ( storageClassIndex == sizeOfActualPool );
27411 0 : out.write ( (char*) (storageArray) , sizeof ( SgQualifiedNameTypeStorageClass ) * sizeOfActualPool) ;
27412 0 : delete [] storageArray;
27413 0 : SgQualifiedNameTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27414 : }
27415 :
27416 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRangeExp );
27417 3 : storageClassIndex = 0 ;
27418 3 : if ( 0 < sizeOfActualPool )
27419 : {
27420 0 : SgRangeExpStorageClass* storageArray = new SgRangeExpStorageClass[sizeOfActualPool] ;
27421 0 : storageClassIndex = SgRangeExp::initializeStorageClassArray (storageArray); ;
27422 0 : assert ( storageClassIndex == sizeOfActualPool );
27423 0 : out.write ( (char*) (storageArray) , sizeof ( SgRangeExpStorageClass ) * sizeOfActualPool) ;
27424 0 : delete [] storageArray;
27425 0 : SgRangeExpStorageClass :: writeEasyStorageDataToFile(out) ;
27426 : }
27427 :
27428 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRangeBasedForStatement );
27429 3 : storageClassIndex = 0 ;
27430 3 : if ( 0 < sizeOfActualPool )
27431 : {
27432 0 : SgRangeBasedForStatementStorageClass* storageArray = new SgRangeBasedForStatementStorageClass[sizeOfActualPool] ;
27433 0 : storageClassIndex = SgRangeBasedForStatement::initializeStorageClassArray (storageArray); ;
27434 0 : assert ( storageClassIndex == sizeOfActualPool );
27435 0 : out.write ( (char*) (storageArray) , sizeof ( SgRangeBasedForStatementStorageClass ) * sizeOfActualPool) ;
27436 0 : delete [] storageArray;
27437 0 : SgRangeBasedForStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27438 : }
27439 :
27440 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgReadStatement );
27441 3 : storageClassIndex = 0 ;
27442 3 : if ( 0 < sizeOfActualPool )
27443 : {
27444 0 : SgReadStatementStorageClass* storageArray = new SgReadStatementStorageClass[sizeOfActualPool] ;
27445 0 : storageClassIndex = SgReadStatement::initializeStorageClassArray (storageArray); ;
27446 0 : assert ( storageClassIndex == sizeOfActualPool );
27447 0 : out.write ( (char*) (storageArray) , sizeof ( SgReadStatementStorageClass ) * sizeOfActualPool) ;
27448 0 : delete [] storageArray;
27449 0 : SgReadStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27450 : }
27451 :
27452 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRealPartOp );
27453 3 : storageClassIndex = 0 ;
27454 3 : if ( 0 < sizeOfActualPool )
27455 : {
27456 0 : SgRealPartOpStorageClass* storageArray = new SgRealPartOpStorageClass[sizeOfActualPool] ;
27457 0 : storageClassIndex = SgRealPartOp::initializeStorageClassArray (storageArray); ;
27458 0 : assert ( storageClassIndex == sizeOfActualPool );
27459 0 : out.write ( (char*) (storageArray) , sizeof ( SgRealPartOpStorageClass ) * sizeOfActualPool) ;
27460 0 : delete [] storageArray;
27461 0 : SgRealPartOpStorageClass :: writeEasyStorageDataToFile(out) ;
27462 : }
27463 :
27464 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRefExp );
27465 3 : storageClassIndex = 0 ;
27466 3 : if ( 0 < sizeOfActualPool )
27467 : {
27468 0 : SgRefExpStorageClass* storageArray = new SgRefExpStorageClass[sizeOfActualPool] ;
27469 0 : storageClassIndex = SgRefExp::initializeStorageClassArray (storageArray); ;
27470 0 : assert ( storageClassIndex == sizeOfActualPool );
27471 0 : out.write ( (char*) (storageArray) , sizeof ( SgRefExpStorageClass ) * sizeOfActualPool) ;
27472 0 : delete [] storageArray;
27473 0 : SgRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
27474 : }
27475 :
27476 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgReferenceType );
27477 3 : storageClassIndex = 0 ;
27478 3 : if ( 0 < sizeOfActualPool )
27479 : {
27480 725 : SgReferenceTypeStorageClass* storageArray = new SgReferenceTypeStorageClass[sizeOfActualPool] ;
27481 1 : storageClassIndex = SgReferenceType::initializeStorageClassArray (storageArray); ;
27482 1 : assert ( storageClassIndex == sizeOfActualPool );
27483 1 : out.write ( (char*) (storageArray) , sizeof ( SgReferenceTypeStorageClass ) * sizeOfActualPool) ;
27484 1 : delete [] storageArray;
27485 1 : SgReferenceTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27486 : }
27487 :
27488 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRenamePair );
27489 3 : storageClassIndex = 0 ;
27490 3 : if ( 0 < sizeOfActualPool )
27491 : {
27492 0 : SgRenamePairStorageClass* storageArray = new SgRenamePairStorageClass[sizeOfActualPool] ;
27493 0 : storageClassIndex = SgRenamePair::initializeStorageClassArray (storageArray); ;
27494 0 : assert ( storageClassIndex == sizeOfActualPool );
27495 0 : out.write ( (char*) (storageArray) , sizeof ( SgRenamePairStorageClass ) * sizeOfActualPool) ;
27496 0 : delete [] storageArray;
27497 0 : SgRenamePairStorageClass :: writeEasyStorageDataToFile(out) ;
27498 : }
27499 :
27500 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRenameSymbol );
27501 3 : storageClassIndex = 0 ;
27502 3 : if ( 0 < sizeOfActualPool )
27503 : {
27504 0 : SgRenameSymbolStorageClass* storageArray = new SgRenameSymbolStorageClass[sizeOfActualPool] ;
27505 0 : storageClassIndex = SgRenameSymbol::initializeStorageClassArray (storageArray); ;
27506 0 : assert ( storageClassIndex == sizeOfActualPool );
27507 0 : out.write ( (char*) (storageArray) , sizeof ( SgRenameSymbolStorageClass ) * sizeOfActualPool) ;
27508 0 : delete [] storageArray;
27509 0 : SgRenameSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
27510 : }
27511 :
27512 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgReturnStmt );
27513 3 : storageClassIndex = 0 ;
27514 3 : if ( 0 < sizeOfActualPool )
27515 : {
27516 1407 : SgReturnStmtStorageClass* storageArray = new SgReturnStmtStorageClass[sizeOfActualPool] ;
27517 2 : storageClassIndex = SgReturnStmt::initializeStorageClassArray (storageArray); ;
27518 2 : assert ( storageClassIndex == sizeOfActualPool );
27519 2 : out.write ( (char*) (storageArray) , sizeof ( SgReturnStmtStorageClass ) * sizeOfActualPool) ;
27520 2 : delete [] storageArray;
27521 2 : SgReturnStmtStorageClass :: writeEasyStorageDataToFile(out) ;
27522 : }
27523 :
27524 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRewindStatement );
27525 3 : storageClassIndex = 0 ;
27526 3 : if ( 0 < sizeOfActualPool )
27527 : {
27528 0 : SgRewindStatementStorageClass* storageArray = new SgRewindStatementStorageClass[sizeOfActualPool] ;
27529 0 : storageClassIndex = SgRewindStatement::initializeStorageClassArray (storageArray); ;
27530 0 : assert ( storageClassIndex == sizeOfActualPool );
27531 0 : out.write ( (char*) (storageArray) , sizeof ( SgRewindStatementStorageClass ) * sizeOfActualPool) ;
27532 0 : delete [] storageArray;
27533 0 : SgRewindStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27534 : }
27535 :
27536 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRshiftAssignOp );
27537 3 : storageClassIndex = 0 ;
27538 3 : if ( 0 < sizeOfActualPool )
27539 : {
27540 3 : SgRshiftAssignOpStorageClass* storageArray = new SgRshiftAssignOpStorageClass[sizeOfActualPool] ;
27541 1 : storageClassIndex = SgRshiftAssignOp::initializeStorageClassArray (storageArray); ;
27542 1 : assert ( storageClassIndex == sizeOfActualPool );
27543 1 : out.write ( (char*) (storageArray) , sizeof ( SgRshiftAssignOpStorageClass ) * sizeOfActualPool) ;
27544 1 : delete [] storageArray;
27545 1 : SgRshiftAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
27546 : }
27547 :
27548 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRshiftOp );
27549 3 : storageClassIndex = 0 ;
27550 3 : if ( 0 < sizeOfActualPool )
27551 : {
27552 9 : SgRshiftOpStorageClass* storageArray = new SgRshiftOpStorageClass[sizeOfActualPool] ;
27553 1 : storageClassIndex = SgRshiftOp::initializeStorageClassArray (storageArray); ;
27554 1 : assert ( storageClassIndex == sizeOfActualPool );
27555 1 : out.write ( (char*) (storageArray) , sizeof ( SgRshiftOpStorageClass ) * sizeOfActualPool) ;
27556 1 : delete [] storageArray;
27557 1 : SgRshiftOpStorageClass :: writeEasyStorageDataToFile(out) ;
27558 : }
27559 :
27560 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgRvalueReferenceType );
27561 3 : storageClassIndex = 0 ;
27562 3 : if ( 0 < sizeOfActualPool )
27563 : {
27564 183 : SgRvalueReferenceTypeStorageClass* storageArray = new SgRvalueReferenceTypeStorageClass[sizeOfActualPool] ;
27565 1 : storageClassIndex = SgRvalueReferenceType::initializeStorageClassArray (storageArray); ;
27566 1 : assert ( storageClassIndex == sizeOfActualPool );
27567 1 : out.write ( (char*) (storageArray) , sizeof ( SgRvalueReferenceTypeStorageClass ) * sizeOfActualPool) ;
27568 1 : delete [] storageArray;
27569 1 : SgRvalueReferenceTypeStorageClass :: writeEasyStorageDataToFile(out) ;
27570 : }
27571 :
27572 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgScopeOp );
27573 3 : storageClassIndex = 0 ;
27574 3 : if ( 0 < sizeOfActualPool )
27575 : {
27576 0 : SgScopeOpStorageClass* storageArray = new SgScopeOpStorageClass[sizeOfActualPool] ;
27577 0 : storageClassIndex = SgScopeOp::initializeStorageClassArray (storageArray); ;
27578 0 : assert ( storageClassIndex == sizeOfActualPool );
27579 0 : out.write ( (char*) (storageArray) , sizeof ( SgScopeOpStorageClass ) * sizeOfActualPool) ;
27580 0 : delete [] storageArray;
27581 0 : SgScopeOpStorageClass :: writeEasyStorageDataToFile(out) ;
27582 : }
27583 :
27584 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgScopeStatement );
27585 3 : storageClassIndex = 0 ;
27586 3 : if ( 0 < sizeOfActualPool )
27587 : {
27588 0 : SgScopeStatementStorageClass* storageArray = new SgScopeStatementStorageClass[sizeOfActualPool] ;
27589 0 : storageClassIndex = SgScopeStatement::initializeStorageClassArray (storageArray); ;
27590 0 : assert ( storageClassIndex == sizeOfActualPool );
27591 0 : out.write ( (char*) (storageArray) , sizeof ( SgScopeStatementStorageClass ) * sizeOfActualPool) ;
27592 0 : delete [] storageArray;
27593 0 : SgScopeStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27594 : }
27595 :
27596 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSequenceStatement );
27597 3 : storageClassIndex = 0 ;
27598 3 : if ( 0 < sizeOfActualPool )
27599 : {
27600 0 : SgSequenceStatementStorageClass* storageArray = new SgSequenceStatementStorageClass[sizeOfActualPool] ;
27601 0 : storageClassIndex = SgSequenceStatement::initializeStorageClassArray (storageArray); ;
27602 0 : assert ( storageClassIndex == sizeOfActualPool );
27603 0 : out.write ( (char*) (storageArray) , sizeof ( SgSequenceStatementStorageClass ) * sizeOfActualPool) ;
27604 0 : delete [] storageArray;
27605 0 : SgSequenceStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27606 : }
27607 :
27608 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSetComprehension );
27609 3 : storageClassIndex = 0 ;
27610 3 : if ( 0 < sizeOfActualPool )
27611 : {
27612 0 : SgSetComprehensionStorageClass* storageArray = new SgSetComprehensionStorageClass[sizeOfActualPool] ;
27613 0 : storageClassIndex = SgSetComprehension::initializeStorageClassArray (storageArray); ;
27614 0 : assert ( storageClassIndex == sizeOfActualPool );
27615 0 : out.write ( (char*) (storageArray) , sizeof ( SgSetComprehensionStorageClass ) * sizeOfActualPool) ;
27616 0 : delete [] storageArray;
27617 0 : SgSetComprehensionStorageClass :: writeEasyStorageDataToFile(out) ;
27618 : }
27619 :
27620 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgShortVal );
27621 3 : storageClassIndex = 0 ;
27622 3 : if ( 0 < sizeOfActualPool )
27623 : {
27624 0 : SgShortValStorageClass* storageArray = new SgShortValStorageClass[sizeOfActualPool] ;
27625 0 : storageClassIndex = SgShortVal::initializeStorageClassArray (storageArray); ;
27626 0 : assert ( storageClassIndex == sizeOfActualPool );
27627 0 : out.write ( (char*) (storageArray) , sizeof ( SgShortValStorageClass ) * sizeOfActualPool) ;
27628 0 : delete [] storageArray;
27629 0 : SgShortValStorageClass :: writeEasyStorageDataToFile(out) ;
27630 : }
27631 :
27632 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDBinaryOp );
27633 3 : storageClassIndex = 0 ;
27634 3 : if ( 0 < sizeOfActualPool )
27635 : {
27636 0 : SgSIMDBinaryOpStorageClass* storageArray = new SgSIMDBinaryOpStorageClass[sizeOfActualPool] ;
27637 0 : storageClassIndex = SgSIMDBinaryOp::initializeStorageClassArray (storageArray); ;
27638 0 : assert ( storageClassIndex == sizeOfActualPool );
27639 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDBinaryOpStorageClass ) * sizeOfActualPool) ;
27640 0 : delete [] storageArray;
27641 0 : SgSIMDBinaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
27642 : }
27643 :
27644 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDAddOp );
27645 3 : storageClassIndex = 0 ;
27646 3 : if ( 0 < sizeOfActualPool )
27647 : {
27648 0 : SgSIMDAddOpStorageClass* storageArray = new SgSIMDAddOpStorageClass[sizeOfActualPool] ;
27649 0 : storageClassIndex = SgSIMDAddOp::initializeStorageClassArray (storageArray); ;
27650 0 : assert ( storageClassIndex == sizeOfActualPool );
27651 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDAddOpStorageClass ) * sizeOfActualPool) ;
27652 0 : delete [] storageArray;
27653 0 : SgSIMDAddOpStorageClass :: writeEasyStorageDataToFile(out) ;
27654 : }
27655 :
27656 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDSubOp );
27657 3 : storageClassIndex = 0 ;
27658 3 : if ( 0 < sizeOfActualPool )
27659 : {
27660 0 : SgSIMDSubOpStorageClass* storageArray = new SgSIMDSubOpStorageClass[sizeOfActualPool] ;
27661 0 : storageClassIndex = SgSIMDSubOp::initializeStorageClassArray (storageArray); ;
27662 0 : assert ( storageClassIndex == sizeOfActualPool );
27663 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDSubOpStorageClass ) * sizeOfActualPool) ;
27664 0 : delete [] storageArray;
27665 0 : SgSIMDSubOpStorageClass :: writeEasyStorageDataToFile(out) ;
27666 : }
27667 :
27668 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDMulOp );
27669 3 : storageClassIndex = 0 ;
27670 3 : if ( 0 < sizeOfActualPool )
27671 : {
27672 0 : SgSIMDMulOpStorageClass* storageArray = new SgSIMDMulOpStorageClass[sizeOfActualPool] ;
27673 0 : storageClassIndex = SgSIMDMulOp::initializeStorageClassArray (storageArray); ;
27674 0 : assert ( storageClassIndex == sizeOfActualPool );
27675 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDMulOpStorageClass ) * sizeOfActualPool) ;
27676 0 : delete [] storageArray;
27677 0 : SgSIMDMulOpStorageClass :: writeEasyStorageDataToFile(out) ;
27678 : }
27679 :
27680 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDDivOp );
27681 3 : storageClassIndex = 0 ;
27682 3 : if ( 0 < sizeOfActualPool )
27683 : {
27684 0 : SgSIMDDivOpStorageClass* storageArray = new SgSIMDDivOpStorageClass[sizeOfActualPool] ;
27685 0 : storageClassIndex = SgSIMDDivOp::initializeStorageClassArray (storageArray); ;
27686 0 : assert ( storageClassIndex == sizeOfActualPool );
27687 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDDivOpStorageClass ) * sizeOfActualPool) ;
27688 0 : delete [] storageArray;
27689 0 : SgSIMDDivOpStorageClass :: writeEasyStorageDataToFile(out) ;
27690 : }
27691 :
27692 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDFmaOp );
27693 3 : storageClassIndex = 0 ;
27694 3 : if ( 0 < sizeOfActualPool )
27695 : {
27696 0 : SgSIMDFmaOpStorageClass* storageArray = new SgSIMDFmaOpStorageClass[sizeOfActualPool] ;
27697 0 : storageClassIndex = SgSIMDFmaOp::initializeStorageClassArray (storageArray); ;
27698 0 : assert ( storageClassIndex == sizeOfActualPool );
27699 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDFmaOpStorageClass ) * sizeOfActualPool) ;
27700 0 : delete [] storageArray;
27701 0 : SgSIMDFmaOpStorageClass :: writeEasyStorageDataToFile(out) ;
27702 : }
27703 :
27704 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDLoad );
27705 3 : storageClassIndex = 0 ;
27706 3 : if ( 0 < sizeOfActualPool )
27707 : {
27708 0 : SgSIMDLoadStorageClass* storageArray = new SgSIMDLoadStorageClass[sizeOfActualPool] ;
27709 0 : storageClassIndex = SgSIMDLoad::initializeStorageClassArray (storageArray); ;
27710 0 : assert ( storageClassIndex == sizeOfActualPool );
27711 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDLoadStorageClass ) * sizeOfActualPool) ;
27712 0 : delete [] storageArray;
27713 0 : SgSIMDLoadStorageClass :: writeEasyStorageDataToFile(out) ;
27714 : }
27715 :
27716 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDBroadcast );
27717 3 : storageClassIndex = 0 ;
27718 3 : if ( 0 < sizeOfActualPool )
27719 : {
27720 0 : SgSIMDBroadcastStorageClass* storageArray = new SgSIMDBroadcastStorageClass[sizeOfActualPool] ;
27721 0 : storageClassIndex = SgSIMDBroadcast::initializeStorageClassArray (storageArray); ;
27722 0 : assert ( storageClassIndex == sizeOfActualPool );
27723 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDBroadcastStorageClass ) * sizeOfActualPool) ;
27724 0 : delete [] storageArray;
27725 0 : SgSIMDBroadcastStorageClass :: writeEasyStorageDataToFile(out) ;
27726 : }
27727 :
27728 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDStore );
27729 3 : storageClassIndex = 0 ;
27730 3 : if ( 0 < sizeOfActualPool )
27731 : {
27732 0 : SgSIMDStoreStorageClass* storageArray = new SgSIMDStoreStorageClass[sizeOfActualPool] ;
27733 0 : storageClassIndex = SgSIMDStore::initializeStorageClassArray (storageArray); ;
27734 0 : assert ( storageClassIndex == sizeOfActualPool );
27735 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDStoreStorageClass ) * sizeOfActualPool) ;
27736 0 : delete [] storageArray;
27737 0 : SgSIMDStoreStorageClass :: writeEasyStorageDataToFile(out) ;
27738 : }
27739 :
27740 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDPartialStore );
27741 3 : storageClassIndex = 0 ;
27742 3 : if ( 0 < sizeOfActualPool )
27743 : {
27744 0 : SgSIMDPartialStoreStorageClass* storageArray = new SgSIMDPartialStoreStorageClass[sizeOfActualPool] ;
27745 0 : storageClassIndex = SgSIMDPartialStore::initializeStorageClassArray (storageArray); ;
27746 0 : assert ( storageClassIndex == sizeOfActualPool );
27747 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDPartialStoreStorageClass ) * sizeOfActualPool) ;
27748 0 : delete [] storageArray;
27749 0 : SgSIMDPartialStoreStorageClass :: writeEasyStorageDataToFile(out) ;
27750 : }
27751 :
27752 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDScalarStore );
27753 3 : storageClassIndex = 0 ;
27754 3 : if ( 0 < sizeOfActualPool )
27755 : {
27756 0 : SgSIMDScalarStoreStorageClass* storageArray = new SgSIMDScalarStoreStorageClass[sizeOfActualPool] ;
27757 0 : storageClassIndex = SgSIMDScalarStore::initializeStorageClassArray (storageArray); ;
27758 0 : assert ( storageClassIndex == sizeOfActualPool );
27759 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDScalarStoreStorageClass ) * sizeOfActualPool) ;
27760 0 : delete [] storageArray;
27761 0 : SgSIMDScalarStoreStorageClass :: writeEasyStorageDataToFile(out) ;
27762 : }
27763 :
27764 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDGather );
27765 3 : storageClassIndex = 0 ;
27766 3 : if ( 0 < sizeOfActualPool )
27767 : {
27768 0 : SgSIMDGatherStorageClass* storageArray = new SgSIMDGatherStorageClass[sizeOfActualPool] ;
27769 0 : storageClassIndex = SgSIMDGather::initializeStorageClassArray (storageArray); ;
27770 0 : assert ( storageClassIndex == sizeOfActualPool );
27771 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDGatherStorageClass ) * sizeOfActualPool) ;
27772 0 : delete [] storageArray;
27773 0 : SgSIMDGatherStorageClass :: writeEasyStorageDataToFile(out) ;
27774 : }
27775 :
27776 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDExplicitGather );
27777 3 : storageClassIndex = 0 ;
27778 3 : if ( 0 < sizeOfActualPool )
27779 : {
27780 0 : SgSIMDExplicitGatherStorageClass* storageArray = new SgSIMDExplicitGatherStorageClass[sizeOfActualPool] ;
27781 0 : storageClassIndex = SgSIMDExplicitGather::initializeStorageClassArray (storageArray); ;
27782 0 : assert ( storageClassIndex == sizeOfActualPool );
27783 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDExplicitGatherStorageClass ) * sizeOfActualPool) ;
27784 0 : delete [] storageArray;
27785 0 : SgSIMDExplicitGatherStorageClass :: writeEasyStorageDataToFile(out) ;
27786 : }
27787 :
27788 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSIMDScatter );
27789 3 : storageClassIndex = 0 ;
27790 3 : if ( 0 < sizeOfActualPool )
27791 : {
27792 0 : SgSIMDScatterStorageClass* storageArray = new SgSIMDScatterStorageClass[sizeOfActualPool] ;
27793 0 : storageClassIndex = SgSIMDScatter::initializeStorageClassArray (storageArray); ;
27794 0 : assert ( storageClassIndex == sizeOfActualPool );
27795 0 : out.write ( (char*) (storageArray) , sizeof ( SgSIMDScatterStorageClass ) * sizeOfActualPool) ;
27796 0 : delete [] storageArray;
27797 0 : SgSIMDScatterStorageClass :: writeEasyStorageDataToFile(out) ;
27798 : }
27799 :
27800 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSizeOfOp );
27801 3 : storageClassIndex = 0 ;
27802 3 : if ( 0 < sizeOfActualPool )
27803 : {
27804 100 : SgSizeOfOpStorageClass* storageArray = new SgSizeOfOpStorageClass[sizeOfActualPool] ;
27805 2 : storageClassIndex = SgSizeOfOp::initializeStorageClassArray (storageArray); ;
27806 2 : assert ( storageClassIndex == sizeOfActualPool );
27807 2 : out.write ( (char*) (storageArray) , sizeof ( SgSizeOfOpStorageClass ) * sizeOfActualPool) ;
27808 2 : delete [] storageArray;
27809 2 : SgSizeOfOpStorageClass :: writeEasyStorageDataToFile(out) ;
27810 : }
27811 :
27812 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgAlignOfOp );
27813 3 : storageClassIndex = 0 ;
27814 3 : if ( 0 < sizeOfActualPool )
27815 : {
27816 6 : SgAlignOfOpStorageClass* storageArray = new SgAlignOfOpStorageClass[sizeOfActualPool] ;
27817 1 : storageClassIndex = SgAlignOfOp::initializeStorageClassArray (storageArray); ;
27818 1 : assert ( storageClassIndex == sizeOfActualPool );
27819 1 : out.write ( (char*) (storageArray) , sizeof ( SgAlignOfOpStorageClass ) * sizeOfActualPool) ;
27820 1 : delete [] storageArray;
27821 1 : SgAlignOfOpStorageClass :: writeEasyStorageDataToFile(out) ;
27822 : }
27823 :
27824 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSourceFile );
27825 3 : storageClassIndex = 0 ;
27826 3 : if ( 0 < sizeOfActualPool )
27827 : {
27828 201 : SgSourceFileStorageClass* storageArray = new SgSourceFileStorageClass[sizeOfActualPool] ;
27829 3 : storageClassIndex = SgSourceFile::initializeStorageClassArray (storageArray); ;
27830 3 : assert ( storageClassIndex == sizeOfActualPool );
27831 3 : out.write ( (char*) (storageArray) , sizeof ( SgSourceFileStorageClass ) * sizeOfActualPool) ;
27832 3 : delete [] storageArray;
27833 3 : SgSourceFileStorageClass :: writeEasyStorageDataToFile(out) ;
27834 : }
27835 :
27836 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSpaceshipOp );
27837 3 : storageClassIndex = 0 ;
27838 3 : if ( 0 < sizeOfActualPool )
27839 : {
27840 0 : SgSpaceshipOpStorageClass* storageArray = new SgSpaceshipOpStorageClass[sizeOfActualPool] ;
27841 0 : storageClassIndex = SgSpaceshipOp::initializeStorageClassArray (storageArray); ;
27842 0 : assert ( storageClassIndex == sizeOfActualPool );
27843 0 : out.write ( (char*) (storageArray) , sizeof ( SgSpaceshipOpStorageClass ) * sizeOfActualPool) ;
27844 0 : delete [] storageArray;
27845 0 : SgSpaceshipOpStorageClass :: writeEasyStorageDataToFile(out) ;
27846 : }
27847 :
27848 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSpawnStmt );
27849 3 : storageClassIndex = 0 ;
27850 3 : if ( 0 < sizeOfActualPool )
27851 : {
27852 0 : SgSpawnStmtStorageClass* storageArray = new SgSpawnStmtStorageClass[sizeOfActualPool] ;
27853 0 : storageClassIndex = SgSpawnStmt::initializeStorageClassArray (storageArray); ;
27854 0 : assert ( storageClassIndex == sizeOfActualPool );
27855 0 : out.write ( (char*) (storageArray) , sizeof ( SgSpawnStmtStorageClass ) * sizeOfActualPool) ;
27856 0 : delete [] storageArray;
27857 0 : SgSpawnStmtStorageClass :: writeEasyStorageDataToFile(out) ;
27858 : }
27859 :
27860 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSyncAllStatement );
27861 3 : storageClassIndex = 0 ;
27862 3 : if ( 0 < sizeOfActualPool )
27863 : {
27864 0 : SgSyncAllStatementStorageClass* storageArray = new SgSyncAllStatementStorageClass[sizeOfActualPool] ;
27865 0 : storageClassIndex = SgSyncAllStatement::initializeStorageClassArray (storageArray); ;
27866 0 : assert ( storageClassIndex == sizeOfActualPool );
27867 0 : out.write ( (char*) (storageArray) , sizeof ( SgSyncAllStatementStorageClass ) * sizeOfActualPool) ;
27868 0 : delete [] storageArray;
27869 0 : SgSyncAllStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27870 : }
27871 :
27872 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSyncImagesStatement );
27873 3 : storageClassIndex = 0 ;
27874 3 : if ( 0 < sizeOfActualPool )
27875 : {
27876 0 : SgSyncImagesStatementStorageClass* storageArray = new SgSyncImagesStatementStorageClass[sizeOfActualPool] ;
27877 0 : storageClassIndex = SgSyncImagesStatement::initializeStorageClassArray (storageArray); ;
27878 0 : assert ( storageClassIndex == sizeOfActualPool );
27879 0 : out.write ( (char*) (storageArray) , sizeof ( SgSyncImagesStatementStorageClass ) * sizeOfActualPool) ;
27880 0 : delete [] storageArray;
27881 0 : SgSyncImagesStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27882 : }
27883 :
27884 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSyncMemoryStatement );
27885 3 : storageClassIndex = 0 ;
27886 3 : if ( 0 < sizeOfActualPool )
27887 : {
27888 0 : SgSyncMemoryStatementStorageClass* storageArray = new SgSyncMemoryStatementStorageClass[sizeOfActualPool] ;
27889 0 : storageClassIndex = SgSyncMemoryStatement::initializeStorageClassArray (storageArray); ;
27890 0 : assert ( storageClassIndex == sizeOfActualPool );
27891 0 : out.write ( (char*) (storageArray) , sizeof ( SgSyncMemoryStatementStorageClass ) * sizeOfActualPool) ;
27892 0 : delete [] storageArray;
27893 0 : SgSyncMemoryStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27894 : }
27895 :
27896 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSyncTeamStatement );
27897 3 : storageClassIndex = 0 ;
27898 3 : if ( 0 < sizeOfActualPool )
27899 : {
27900 0 : SgSyncTeamStatementStorageClass* storageArray = new SgSyncTeamStatementStorageClass[sizeOfActualPool] ;
27901 0 : storageClassIndex = SgSyncTeamStatement::initializeStorageClassArray (storageArray); ;
27902 0 : assert ( storageClassIndex == sizeOfActualPool );
27903 0 : out.write ( (char*) (storageArray) , sizeof ( SgSyncTeamStatementStorageClass ) * sizeOfActualPool) ;
27904 0 : delete [] storageArray;
27905 0 : SgSyncTeamStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27906 : }
27907 :
27908 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgLockStatement );
27909 3 : storageClassIndex = 0 ;
27910 3 : if ( 0 < sizeOfActualPool )
27911 : {
27912 0 : SgLockStatementStorageClass* storageArray = new SgLockStatementStorageClass[sizeOfActualPool] ;
27913 0 : storageClassIndex = SgLockStatement::initializeStorageClassArray (storageArray); ;
27914 0 : assert ( storageClassIndex == sizeOfActualPool );
27915 0 : out.write ( (char*) (storageArray) , sizeof ( SgLockStatementStorageClass ) * sizeOfActualPool) ;
27916 0 : delete [] storageArray;
27917 0 : SgLockStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27918 : }
27919 :
27920 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnlockStatement );
27921 3 : storageClassIndex = 0 ;
27922 3 : if ( 0 < sizeOfActualPool )
27923 : {
27924 0 : SgUnlockStatementStorageClass* storageArray = new SgUnlockStatementStorageClass[sizeOfActualPool] ;
27925 0 : storageClassIndex = SgUnlockStatement::initializeStorageClassArray (storageArray); ;
27926 0 : assert ( storageClassIndex == sizeOfActualPool );
27927 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnlockStatementStorageClass ) * sizeOfActualPool) ;
27928 0 : delete [] storageArray;
27929 0 : SgUnlockStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27930 : }
27931 :
27932 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgProcessControlStatement );
27933 3 : storageClassIndex = 0 ;
27934 3 : if ( 0 < sizeOfActualPool )
27935 : {
27936 0 : SgProcessControlStatementStorageClass* storageArray = new SgProcessControlStatementStorageClass[sizeOfActualPool] ;
27937 0 : storageClassIndex = SgProcessControlStatement::initializeStorageClassArray (storageArray); ;
27938 0 : assert ( storageClassIndex == sizeOfActualPool );
27939 0 : out.write ( (char*) (storageArray) , sizeof ( SgProcessControlStatementStorageClass ) * sizeOfActualPool) ;
27940 0 : delete [] storageArray;
27941 0 : SgProcessControlStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27942 : }
27943 :
27944 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSpecialFunctionModifier );
27945 3 : storageClassIndex = 0 ;
27946 3 : if ( 0 < sizeOfActualPool )
27947 : {
27948 0 : SgSpecialFunctionModifierStorageClass* storageArray = new SgSpecialFunctionModifierStorageClass[sizeOfActualPool] ;
27949 0 : storageClassIndex = SgSpecialFunctionModifier::initializeStorageClassArray (storageArray); ;
27950 0 : assert ( storageClassIndex == sizeOfActualPool );
27951 0 : out.write ( (char*) (storageArray) , sizeof ( SgSpecialFunctionModifierStorageClass ) * sizeOfActualPool) ;
27952 0 : delete [] storageArray;
27953 0 : SgSpecialFunctionModifierStorageClass :: writeEasyStorageDataToFile(out) ;
27954 : }
27955 :
27956 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStatement );
27957 3 : storageClassIndex = 0 ;
27958 3 : if ( 0 < sizeOfActualPool )
27959 : {
27960 0 : SgStatementStorageClass* storageArray = new SgStatementStorageClass[sizeOfActualPool] ;
27961 0 : storageClassIndex = SgStatement::initializeStorageClassArray (storageArray); ;
27962 0 : assert ( storageClassIndex == sizeOfActualPool );
27963 0 : out.write ( (char*) (storageArray) , sizeof ( SgStatementStorageClass ) * sizeOfActualPool) ;
27964 0 : delete [] storageArray;
27965 0 : SgStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27966 : }
27967 :
27968 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStaticAssertionDeclaration );
27969 3 : storageClassIndex = 0 ;
27970 3 : if ( 0 < sizeOfActualPool )
27971 : {
27972 15 : SgStaticAssertionDeclarationStorageClass* storageArray = new SgStaticAssertionDeclarationStorageClass[sizeOfActualPool] ;
27973 1 : storageClassIndex = SgStaticAssertionDeclaration::initializeStorageClassArray (storageArray); ;
27974 1 : assert ( storageClassIndex == sizeOfActualPool );
27975 1 : out.write ( (char*) (storageArray) , sizeof ( SgStaticAssertionDeclarationStorageClass ) * sizeOfActualPool) ;
27976 1 : delete [] storageArray;
27977 1 : SgStaticAssertionDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
27978 : }
27979 :
27980 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStmtDeclarationStatement );
27981 3 : storageClassIndex = 0 ;
27982 3 : if ( 0 < sizeOfActualPool )
27983 : {
27984 0 : SgStmtDeclarationStatementStorageClass* storageArray = new SgStmtDeclarationStatementStorageClass[sizeOfActualPool] ;
27985 0 : storageClassIndex = SgStmtDeclarationStatement::initializeStorageClassArray (storageArray); ;
27986 0 : assert ( storageClassIndex == sizeOfActualPool );
27987 0 : out.write ( (char*) (storageArray) , sizeof ( SgStmtDeclarationStatementStorageClass ) * sizeOfActualPool) ;
27988 0 : delete [] storageArray;
27989 0 : SgStmtDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
27990 : }
27991 :
27992 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStatementExpression );
27993 3 : storageClassIndex = 0 ;
27994 3 : if ( 0 < sizeOfActualPool )
27995 : {
27996 0 : SgStatementExpressionStorageClass* storageArray = new SgStatementExpressionStorageClass[sizeOfActualPool] ;
27997 0 : storageClassIndex = SgStatementExpression::initializeStorageClassArray (storageArray); ;
27998 0 : assert ( storageClassIndex == sizeOfActualPool );
27999 0 : out.write ( (char*) (storageArray) , sizeof ( SgStatementExpressionStorageClass ) * sizeOfActualPool) ;
28000 0 : delete [] storageArray;
28001 0 : SgStatementExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
28002 : }
28003 :
28004 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStatementFunctionStatement );
28005 3 : storageClassIndex = 0 ;
28006 3 : if ( 0 < sizeOfActualPool )
28007 : {
28008 0 : SgStatementFunctionStatementStorageClass* storageArray = new SgStatementFunctionStatementStorageClass[sizeOfActualPool] ;
28009 0 : storageClassIndex = SgStatementFunctionStatement::initializeStorageClassArray (storageArray); ;
28010 0 : assert ( storageClassIndex == sizeOfActualPool );
28011 0 : out.write ( (char*) (storageArray) , sizeof ( SgStatementFunctionStatementStorageClass ) * sizeOfActualPool) ;
28012 0 : delete [] storageArray;
28013 0 : SgStatementFunctionStatementStorageClass :: writeEasyStorageDataToFile(out) ;
28014 : }
28015 :
28016 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStorageModifier );
28017 3 : storageClassIndex = 0 ;
28018 3 : if ( 0 < sizeOfActualPool )
28019 : {
28020 2 : SgStorageModifierStorageClass* storageArray = new SgStorageModifierStorageClass[sizeOfActualPool] ;
28021 2 : storageClassIndex = SgStorageModifier::initializeStorageClassArray (storageArray); ;
28022 2 : assert ( storageClassIndex == sizeOfActualPool );
28023 2 : out.write ( (char*) (storageArray) , sizeof ( SgStorageModifierStorageClass ) * sizeOfActualPool) ;
28024 2 : delete [] storageArray;
28025 : }
28026 :
28027 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStringConversion );
28028 3 : storageClassIndex = 0 ;
28029 3 : if ( 0 < sizeOfActualPool )
28030 : {
28031 0 : SgStringConversionStorageClass* storageArray = new SgStringConversionStorageClass[sizeOfActualPool] ;
28032 0 : storageClassIndex = SgStringConversion::initializeStorageClassArray (storageArray); ;
28033 0 : assert ( storageClassIndex == sizeOfActualPool );
28034 0 : out.write ( (char*) (storageArray) , sizeof ( SgStringConversionStorageClass ) * sizeOfActualPool) ;
28035 0 : delete [] storageArray;
28036 0 : SgStringConversionStorageClass :: writeEasyStorageDataToFile(out) ;
28037 : }
28038 :
28039 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStringKeyedBidirectionalGraph );
28040 3 : storageClassIndex = 0 ;
28041 3 : if ( 0 < sizeOfActualPool )
28042 : {
28043 0 : SgStringKeyedBidirectionalGraphStorageClass* storageArray = new SgStringKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
28044 0 : storageClassIndex = SgStringKeyedBidirectionalGraph::initializeStorageClassArray (storageArray); ;
28045 0 : assert ( storageClassIndex == sizeOfActualPool );
28046 0 : out.write ( (char*) (storageArray) , sizeof ( SgStringKeyedBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
28047 0 : delete [] storageArray;
28048 0 : SgStringKeyedBidirectionalGraphStorageClass :: writeEasyStorageDataToFile(out) ;
28049 : }
28050 :
28051 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStringVal );
28052 3 : storageClassIndex = 0 ;
28053 3 : if ( 0 < sizeOfActualPool )
28054 : {
28055 86 : SgStringValStorageClass* storageArray = new SgStringValStorageClass[sizeOfActualPool] ;
28056 3 : storageClassIndex = SgStringVal::initializeStorageClassArray (storageArray); ;
28057 3 : assert ( storageClassIndex == sizeOfActualPool );
28058 3 : out.write ( (char*) (storageArray) , sizeof ( SgStringValStorageClass ) * sizeOfActualPool) ;
28059 3 : delete [] storageArray;
28060 3 : SgStringValStorageClass :: writeEasyStorageDataToFile(out) ;
28061 : }
28062 :
28063 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgStructureModifier );
28064 3 : storageClassIndex = 0 ;
28065 3 : if ( 0 < sizeOfActualPool )
28066 : {
28067 0 : SgStructureModifierStorageClass* storageArray = new SgStructureModifierStorageClass[sizeOfActualPool] ;
28068 0 : storageClassIndex = SgStructureModifier::initializeStorageClassArray (storageArray); ;
28069 0 : assert ( storageClassIndex == sizeOfActualPool );
28070 0 : out.write ( (char*) (storageArray) , sizeof ( SgStructureModifierStorageClass ) * sizeOfActualPool) ;
28071 0 : delete [] storageArray;
28072 : }
28073 :
28074 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSubscriptExpression );
28075 3 : storageClassIndex = 0 ;
28076 3 : if ( 0 < sizeOfActualPool )
28077 : {
28078 0 : SgSubscriptExpressionStorageClass* storageArray = new SgSubscriptExpressionStorageClass[sizeOfActualPool] ;
28079 0 : storageClassIndex = SgSubscriptExpression::initializeStorageClassArray (storageArray); ;
28080 0 : assert ( storageClassIndex == sizeOfActualPool );
28081 0 : out.write ( (char*) (storageArray) , sizeof ( SgSubscriptExpressionStorageClass ) * sizeOfActualPool) ;
28082 0 : delete [] storageArray;
28083 0 : SgSubscriptExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
28084 : }
28085 :
28086 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSubtractOp );
28087 3 : storageClassIndex = 0 ;
28088 3 : if ( 0 < sizeOfActualPool )
28089 : {
28090 213 : SgSubtractOpStorageClass* storageArray = new SgSubtractOpStorageClass[sizeOfActualPool] ;
28091 2 : storageClassIndex = SgSubtractOp::initializeStorageClassArray (storageArray); ;
28092 2 : assert ( storageClassIndex == sizeOfActualPool );
28093 2 : out.write ( (char*) (storageArray) , sizeof ( SgSubtractOpStorageClass ) * sizeOfActualPool) ;
28094 2 : delete [] storageArray;
28095 2 : SgSubtractOpStorageClass :: writeEasyStorageDataToFile(out) ;
28096 : }
28097 :
28098 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSupport );
28099 3 : storageClassIndex = 0 ;
28100 3 : if ( 0 < sizeOfActualPool )
28101 : {
28102 0 : SgSupportStorageClass* storageArray = new SgSupportStorageClass[sizeOfActualPool] ;
28103 0 : storageClassIndex = SgSupport::initializeStorageClassArray (storageArray); ;
28104 0 : assert ( storageClassIndex == sizeOfActualPool );
28105 0 : out.write ( (char*) (storageArray) , sizeof ( SgSupportStorageClass ) * sizeOfActualPool) ;
28106 0 : delete [] storageArray;
28107 : }
28108 :
28109 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSwitchStatement );
28110 3 : storageClassIndex = 0 ;
28111 3 : if ( 0 < sizeOfActualPool )
28112 : {
28113 0 : SgSwitchStatementStorageClass* storageArray = new SgSwitchStatementStorageClass[sizeOfActualPool] ;
28114 0 : storageClassIndex = SgSwitchStatement::initializeStorageClassArray (storageArray); ;
28115 0 : assert ( storageClassIndex == sizeOfActualPool );
28116 0 : out.write ( (char*) (storageArray) , sizeof ( SgSwitchStatementStorageClass ) * sizeOfActualPool) ;
28117 0 : delete [] storageArray;
28118 0 : SgSwitchStatementStorageClass :: writeEasyStorageDataToFile(out) ;
28119 : }
28120 :
28121 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSymbolTable );
28122 3 : storageClassIndex = 0 ;
28123 3 : if ( 0 < sizeOfActualPool )
28124 : {
28125 26913 : SgSymbolTableStorageClass* storageArray = new SgSymbolTableStorageClass[sizeOfActualPool] ;
28126 3 : storageClassIndex = SgSymbolTable::initializeStorageClassArray (storageArray); ;
28127 3 : assert ( storageClassIndex == sizeOfActualPool );
28128 3 : out.write ( (char*) (storageArray) , sizeof ( SgSymbolTableStorageClass ) * sizeOfActualPool) ;
28129 3 : delete [] storageArray;
28130 3 : SgSymbolTableStorageClass :: writeEasyStorageDataToFile(out) ;
28131 : }
28132 :
28133 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateArgument );
28134 3 : storageClassIndex = 0 ;
28135 3 : if ( 0 < sizeOfActualPool )
28136 : {
28137 1 : SgTemplateArgumentStorageClass* storageArray = new SgTemplateArgumentStorageClass[sizeOfActualPool] ;
28138 1 : storageClassIndex = SgTemplateArgument::initializeStorageClassArray (storageArray); ;
28139 1 : assert ( storageClassIndex == sizeOfActualPool );
28140 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateArgumentStorageClass ) * sizeOfActualPool) ;
28141 1 : delete [] storageArray;
28142 : }
28143 :
28144 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateArgumentList );
28145 3 : storageClassIndex = 0 ;
28146 3 : if ( 0 < sizeOfActualPool )
28147 : {
28148 0 : SgTemplateArgumentListStorageClass* storageArray = new SgTemplateArgumentListStorageClass[sizeOfActualPool] ;
28149 0 : storageClassIndex = SgTemplateArgumentList::initializeStorageClassArray (storageArray); ;
28150 0 : assert ( storageClassIndex == sizeOfActualPool );
28151 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateArgumentListStorageClass ) * sizeOfActualPool) ;
28152 0 : delete [] storageArray;
28153 0 : SgTemplateArgumentListStorageClass :: writeEasyStorageDataToFile(out) ;
28154 : }
28155 :
28156 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateDeclaration );
28157 3 : storageClassIndex = 0 ;
28158 3 : if ( 0 < sizeOfActualPool )
28159 : {
28160 0 : SgTemplateDeclarationStorageClass* storageArray = new SgTemplateDeclarationStorageClass[sizeOfActualPool] ;
28161 0 : storageClassIndex = SgTemplateDeclaration::initializeStorageClassArray (storageArray); ;
28162 0 : assert ( storageClassIndex == sizeOfActualPool );
28163 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateDeclarationStorageClass ) * sizeOfActualPool) ;
28164 0 : delete [] storageArray;
28165 0 : SgTemplateDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28166 : }
28167 :
28168 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateClassDeclaration );
28169 3 : storageClassIndex = 0 ;
28170 3 : if ( 0 < sizeOfActualPool )
28171 : {
28172 1091 : SgTemplateClassDeclarationStorageClass* storageArray = new SgTemplateClassDeclarationStorageClass[sizeOfActualPool] ;
28173 1 : storageClassIndex = SgTemplateClassDeclaration::initializeStorageClassArray (storageArray); ;
28174 1 : assert ( storageClassIndex == sizeOfActualPool );
28175 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateClassDeclarationStorageClass ) * sizeOfActualPool) ;
28176 1 : delete [] storageArray;
28177 1 : SgTemplateClassDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28178 : }
28179 :
28180 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateClassSymbol );
28181 3 : storageClassIndex = 0 ;
28182 3 : if ( 0 < sizeOfActualPool )
28183 : {
28184 573 : SgTemplateClassSymbolStorageClass* storageArray = new SgTemplateClassSymbolStorageClass[sizeOfActualPool] ;
28185 1 : storageClassIndex = SgTemplateClassSymbol::initializeStorageClassArray (storageArray); ;
28186 1 : assert ( storageClassIndex == sizeOfActualPool );
28187 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateClassSymbolStorageClass ) * sizeOfActualPool) ;
28188 1 : delete [] storageArray;
28189 1 : SgTemplateClassSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28190 : }
28191 :
28192 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateFunctionDeclaration );
28193 3 : storageClassIndex = 0 ;
28194 3 : if ( 0 < sizeOfActualPool )
28195 : {
28196 677 : SgTemplateFunctionDeclarationStorageClass* storageArray = new SgTemplateFunctionDeclarationStorageClass[sizeOfActualPool] ;
28197 1 : storageClassIndex = SgTemplateFunctionDeclaration::initializeStorageClassArray (storageArray); ;
28198 1 : assert ( storageClassIndex == sizeOfActualPool );
28199 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
28200 1 : delete [] storageArray;
28201 1 : SgTemplateFunctionDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28202 : }
28203 :
28204 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateFunctionRefExp );
28205 3 : storageClassIndex = 0 ;
28206 3 : if ( 0 < sizeOfActualPool )
28207 : {
28208 226 : SgTemplateFunctionRefExpStorageClass* storageArray = new SgTemplateFunctionRefExpStorageClass[sizeOfActualPool] ;
28209 1 : storageClassIndex = SgTemplateFunctionRefExp::initializeStorageClassArray (storageArray); ;
28210 1 : assert ( storageClassIndex == sizeOfActualPool );
28211 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateFunctionRefExpStorageClass ) * sizeOfActualPool) ;
28212 1 : delete [] storageArray;
28213 1 : SgTemplateFunctionRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
28214 : }
28215 :
28216 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateFunctionSymbol );
28217 3 : storageClassIndex = 0 ;
28218 3 : if ( 0 < sizeOfActualPool )
28219 : {
28220 341 : SgTemplateFunctionSymbolStorageClass* storageArray = new SgTemplateFunctionSymbolStorageClass[sizeOfActualPool] ;
28221 1 : storageClassIndex = SgTemplateFunctionSymbol::initializeStorageClassArray (storageArray); ;
28222 1 : assert ( storageClassIndex == sizeOfActualPool );
28223 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateFunctionSymbolStorageClass ) * sizeOfActualPool) ;
28224 1 : delete [] storageArray;
28225 1 : SgTemplateFunctionSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28226 : }
28227 :
28228 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateMemberFunctionDeclaration );
28229 3 : storageClassIndex = 0 ;
28230 3 : if ( 0 < sizeOfActualPool )
28231 : {
28232 1906 : SgTemplateMemberFunctionDeclarationStorageClass* storageArray = new SgTemplateMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
28233 1 : storageClassIndex = SgTemplateMemberFunctionDeclaration::initializeStorageClassArray (storageArray); ;
28234 1 : assert ( storageClassIndex == sizeOfActualPool );
28235 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateMemberFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
28236 1 : delete [] storageArray;
28237 1 : SgTemplateMemberFunctionDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28238 : }
28239 :
28240 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateMemberFunctionRefExp );
28241 3 : storageClassIndex = 0 ;
28242 3 : if ( 0 < sizeOfActualPool )
28243 : {
28244 739 : SgTemplateMemberFunctionRefExpStorageClass* storageArray = new SgTemplateMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
28245 1 : storageClassIndex = SgTemplateMemberFunctionRefExp::initializeStorageClassArray (storageArray); ;
28246 1 : assert ( storageClassIndex == sizeOfActualPool );
28247 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateMemberFunctionRefExpStorageClass ) * sizeOfActualPool) ;
28248 1 : delete [] storageArray;
28249 1 : SgTemplateMemberFunctionRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
28250 : }
28251 :
28252 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateMemberFunctionSymbol );
28253 3 : storageClassIndex = 0 ;
28254 3 : if ( 0 < sizeOfActualPool )
28255 : {
28256 1048 : SgTemplateMemberFunctionSymbolStorageClass* storageArray = new SgTemplateMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
28257 1 : storageClassIndex = SgTemplateMemberFunctionSymbol::initializeStorageClassArray (storageArray); ;
28258 1 : assert ( storageClassIndex == sizeOfActualPool );
28259 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateMemberFunctionSymbolStorageClass ) * sizeOfActualPool) ;
28260 1 : delete [] storageArray;
28261 1 : SgTemplateMemberFunctionSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28262 : }
28263 :
28264 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateTypedefDeclaration );
28265 3 : storageClassIndex = 0 ;
28266 3 : if ( 0 < sizeOfActualPool )
28267 : {
28268 96 : SgTemplateTypedefDeclarationStorageClass* storageArray = new SgTemplateTypedefDeclarationStorageClass[sizeOfActualPool] ;
28269 1 : storageClassIndex = SgTemplateTypedefDeclaration::initializeStorageClassArray (storageArray); ;
28270 1 : assert ( storageClassIndex == sizeOfActualPool );
28271 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
28272 1 : delete [] storageArray;
28273 1 : SgTemplateTypedefDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28274 : }
28275 :
28276 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateTypedefSymbol );
28277 3 : storageClassIndex = 0 ;
28278 3 : if ( 0 < sizeOfActualPool )
28279 : {
28280 161 : SgTemplateTypedefSymbolStorageClass* storageArray = new SgTemplateTypedefSymbolStorageClass[sizeOfActualPool] ;
28281 1 : storageClassIndex = SgTemplateTypedefSymbol::initializeStorageClassArray (storageArray); ;
28282 1 : assert ( storageClassIndex == sizeOfActualPool );
28283 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateTypedefSymbolStorageClass ) * sizeOfActualPool) ;
28284 1 : delete [] storageArray;
28285 1 : SgTemplateTypedefSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28286 : }
28287 :
28288 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateVariableDeclaration );
28289 3 : storageClassIndex = 0 ;
28290 3 : if ( 0 < sizeOfActualPool )
28291 : {
28292 103 : SgTemplateVariableDeclarationStorageClass* storageArray = new SgTemplateVariableDeclarationStorageClass[sizeOfActualPool] ;
28293 1 : storageClassIndex = SgTemplateVariableDeclaration::initializeStorageClassArray (storageArray); ;
28294 1 : assert ( storageClassIndex == sizeOfActualPool );
28295 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateVariableDeclarationStorageClass ) * sizeOfActualPool) ;
28296 1 : delete [] storageArray;
28297 1 : SgTemplateVariableDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28298 : }
28299 :
28300 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateVariableSymbol );
28301 3 : storageClassIndex = 0 ;
28302 3 : if ( 0 < sizeOfActualPool )
28303 : {
28304 87 : SgTemplateVariableSymbolStorageClass* storageArray = new SgTemplateVariableSymbolStorageClass[sizeOfActualPool] ;
28305 1 : storageClassIndex = SgTemplateVariableSymbol::initializeStorageClassArray (storageArray); ;
28306 1 : assert ( storageClassIndex == sizeOfActualPool );
28307 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateVariableSymbolStorageClass ) * sizeOfActualPool) ;
28308 1 : delete [] storageArray;
28309 1 : SgTemplateVariableSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28310 : }
28311 :
28312 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateClassDefinition );
28313 3 : storageClassIndex = 0 ;
28314 3 : if ( 0 < sizeOfActualPool )
28315 : {
28316 507 : SgTemplateClassDefinitionStorageClass* storageArray = new SgTemplateClassDefinitionStorageClass[sizeOfActualPool] ;
28317 1 : storageClassIndex = SgTemplateClassDefinition::initializeStorageClassArray (storageArray); ;
28318 1 : assert ( storageClassIndex == sizeOfActualPool );
28319 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateClassDefinitionStorageClass ) * sizeOfActualPool) ;
28320 1 : delete [] storageArray;
28321 1 : SgTemplateClassDefinitionStorageClass :: writeEasyStorageDataToFile(out) ;
28322 : }
28323 :
28324 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateFunctionDefinition );
28325 3 : storageClassIndex = 0 ;
28326 3 : if ( 0 < sizeOfActualPool )
28327 : {
28328 316 : SgTemplateFunctionDefinitionStorageClass* storageArray = new SgTemplateFunctionDefinitionStorageClass[sizeOfActualPool] ;
28329 1 : storageClassIndex = SgTemplateFunctionDefinition::initializeStorageClassArray (storageArray); ;
28330 1 : assert ( storageClassIndex == sizeOfActualPool );
28331 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateFunctionDefinitionStorageClass ) * sizeOfActualPool) ;
28332 1 : delete [] storageArray;
28333 1 : SgTemplateFunctionDefinitionStorageClass :: writeEasyStorageDataToFile(out) ;
28334 : }
28335 :
28336 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationDecl );
28337 3 : storageClassIndex = 0 ;
28338 3 : if ( 0 < sizeOfActualPool )
28339 : {
28340 1320 : SgTemplateInstantiationDeclStorageClass* storageArray = new SgTemplateInstantiationDeclStorageClass[sizeOfActualPool] ;
28341 1 : storageClassIndex = SgTemplateInstantiationDecl::initializeStorageClassArray (storageArray); ;
28342 1 : assert ( storageClassIndex == sizeOfActualPool );
28343 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationDeclStorageClass ) * sizeOfActualPool) ;
28344 1 : delete [] storageArray;
28345 1 : SgTemplateInstantiationDeclStorageClass :: writeEasyStorageDataToFile(out) ;
28346 : }
28347 :
28348 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationDefn );
28349 3 : storageClassIndex = 0 ;
28350 3 : if ( 0 < sizeOfActualPool )
28351 : {
28352 602 : SgTemplateInstantiationDefnStorageClass* storageArray = new SgTemplateInstantiationDefnStorageClass[sizeOfActualPool] ;
28353 1 : storageClassIndex = SgTemplateInstantiationDefn::initializeStorageClassArray (storageArray); ;
28354 1 : assert ( storageClassIndex == sizeOfActualPool );
28355 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationDefnStorageClass ) * sizeOfActualPool) ;
28356 1 : delete [] storageArray;
28357 1 : SgTemplateInstantiationDefnStorageClass :: writeEasyStorageDataToFile(out) ;
28358 : }
28359 :
28360 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationDirectiveStatement );
28361 3 : storageClassIndex = 0 ;
28362 3 : if ( 0 < sizeOfActualPool )
28363 : {
28364 125 : SgTemplateInstantiationDirectiveStatementStorageClass* storageArray = new SgTemplateInstantiationDirectiveStatementStorageClass[sizeOfActualPool] ;
28365 1 : storageClassIndex = SgTemplateInstantiationDirectiveStatement::initializeStorageClassArray (storageArray); ;
28366 1 : assert ( storageClassIndex == sizeOfActualPool );
28367 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationDirectiveStatementStorageClass ) * sizeOfActualPool) ;
28368 1 : delete [] storageArray;
28369 1 : SgTemplateInstantiationDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
28370 : }
28371 :
28372 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationFunctionDecl );
28373 3 : storageClassIndex = 0 ;
28374 3 : if ( 0 < sizeOfActualPool )
28375 : {
28376 284 : SgTemplateInstantiationFunctionDeclStorageClass* storageArray = new SgTemplateInstantiationFunctionDeclStorageClass[sizeOfActualPool] ;
28377 1 : storageClassIndex = SgTemplateInstantiationFunctionDecl::initializeStorageClassArray (storageArray); ;
28378 1 : assert ( storageClassIndex == sizeOfActualPool );
28379 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationFunctionDeclStorageClass ) * sizeOfActualPool) ;
28380 1 : delete [] storageArray;
28381 1 : SgTemplateInstantiationFunctionDeclStorageClass :: writeEasyStorageDataToFile(out) ;
28382 : }
28383 :
28384 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationMemberFunctionDecl );
28385 3 : storageClassIndex = 0 ;
28386 3 : if ( 0 < sizeOfActualPool )
28387 : {
28388 1740 : SgTemplateInstantiationMemberFunctionDeclStorageClass* storageArray = new SgTemplateInstantiationMemberFunctionDeclStorageClass[sizeOfActualPool] ;
28389 1 : storageClassIndex = SgTemplateInstantiationMemberFunctionDecl::initializeStorageClassArray (storageArray); ;
28390 1 : assert ( storageClassIndex == sizeOfActualPool );
28391 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationMemberFunctionDeclStorageClass ) * sizeOfActualPool) ;
28392 1 : delete [] storageArray;
28393 1 : SgTemplateInstantiationMemberFunctionDeclStorageClass :: writeEasyStorageDataToFile(out) ;
28394 : }
28395 :
28396 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateInstantiationTypedefDeclaration );
28397 3 : storageClassIndex = 0 ;
28398 3 : if ( 0 < sizeOfActualPool )
28399 : {
28400 66 : SgTemplateInstantiationTypedefDeclarationStorageClass* storageArray = new SgTemplateInstantiationTypedefDeclarationStorageClass[sizeOfActualPool] ;
28401 1 : storageClassIndex = SgTemplateInstantiationTypedefDeclaration::initializeStorageClassArray (storageArray); ;
28402 1 : assert ( storageClassIndex == sizeOfActualPool );
28403 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateInstantiationTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
28404 1 : delete [] storageArray;
28405 1 : SgTemplateInstantiationTypedefDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
28406 : }
28407 :
28408 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateParameter );
28409 3 : storageClassIndex = 0 ;
28410 3 : if ( 0 < sizeOfActualPool )
28411 : {
28412 1 : SgTemplateParameterStorageClass* storageArray = new SgTemplateParameterStorageClass[sizeOfActualPool] ;
28413 1 : storageClassIndex = SgTemplateParameter::initializeStorageClassArray (storageArray); ;
28414 1 : assert ( storageClassIndex == sizeOfActualPool );
28415 1 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateParameterStorageClass ) * sizeOfActualPool) ;
28416 1 : delete [] storageArray;
28417 : }
28418 :
28419 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateParameterVal );
28420 3 : storageClassIndex = 0 ;
28421 3 : if ( 0 < sizeOfActualPool )
28422 : {
28423 0 : SgTemplateParameterValStorageClass* storageArray = new SgTemplateParameterValStorageClass[sizeOfActualPool] ;
28424 0 : storageClassIndex = SgTemplateParameterVal::initializeStorageClassArray (storageArray); ;
28425 0 : assert ( storageClassIndex == sizeOfActualPool );
28426 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateParameterValStorageClass ) * sizeOfActualPool) ;
28427 0 : delete [] storageArray;
28428 0 : SgTemplateParameterValStorageClass :: writeEasyStorageDataToFile(out) ;
28429 : }
28430 :
28431 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateParameterList );
28432 3 : storageClassIndex = 0 ;
28433 3 : if ( 0 < sizeOfActualPool )
28434 : {
28435 0 : SgTemplateParameterListStorageClass* storageArray = new SgTemplateParameterListStorageClass[sizeOfActualPool] ;
28436 0 : storageClassIndex = SgTemplateParameterList::initializeStorageClassArray (storageArray); ;
28437 0 : assert ( storageClassIndex == sizeOfActualPool );
28438 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateParameterListStorageClass ) * sizeOfActualPool) ;
28439 0 : delete [] storageArray;
28440 0 : SgTemplateParameterListStorageClass :: writeEasyStorageDataToFile(out) ;
28441 : }
28442 :
28443 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateSymbol );
28444 3 : storageClassIndex = 0 ;
28445 3 : if ( 0 < sizeOfActualPool )
28446 : {
28447 0 : SgTemplateSymbolStorageClass* storageArray = new SgTemplateSymbolStorageClass[sizeOfActualPool] ;
28448 0 : storageClassIndex = SgTemplateSymbol::initializeStorageClassArray (storageArray); ;
28449 0 : assert ( storageClassIndex == sizeOfActualPool );
28450 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateSymbolStorageClass ) * sizeOfActualPool) ;
28451 0 : delete [] storageArray;
28452 0 : SgTemplateSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
28453 : }
28454 :
28455 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTemplateType );
28456 3 : storageClassIndex = 0 ;
28457 3 : if ( 0 < sizeOfActualPool )
28458 : {
28459 0 : SgTemplateTypeStorageClass* storageArray = new SgTemplateTypeStorageClass[sizeOfActualPool] ;
28460 0 : storageClassIndex = SgTemplateType::initializeStorageClassArray (storageArray); ;
28461 0 : assert ( storageClassIndex == sizeOfActualPool );
28462 0 : out.write ( (char*) (storageArray) , sizeof ( SgTemplateTypeStorageClass ) * sizeOfActualPool) ;
28463 0 : delete [] storageArray;
28464 0 : SgTemplateTypeStorageClass :: writeEasyStorageDataToFile(out) ;
28465 : }
28466 :
28467 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgThisExp );
28468 3 : storageClassIndex = 0 ;
28469 3 : if ( 0 < sizeOfActualPool )
28470 : {
28471 1237 : SgThisExpStorageClass* storageArray = new SgThisExpStorageClass[sizeOfActualPool] ;
28472 1 : storageClassIndex = SgThisExp::initializeStorageClassArray (storageArray); ;
28473 1 : assert ( storageClassIndex == sizeOfActualPool );
28474 1 : out.write ( (char*) (storageArray) , sizeof ( SgThisExpStorageClass ) * sizeOfActualPool) ;
28475 1 : delete [] storageArray;
28476 1 : SgThisExpStorageClass :: writeEasyStorageDataToFile(out) ;
28477 : }
28478 :
28479 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeTraitBuiltinOperator );
28480 3 : storageClassIndex = 0 ;
28481 3 : if ( 0 < sizeOfActualPool )
28482 : {
28483 43 : SgTypeTraitBuiltinOperatorStorageClass* storageArray = new SgTypeTraitBuiltinOperatorStorageClass[sizeOfActualPool] ;
28484 1 : storageClassIndex = SgTypeTraitBuiltinOperator::initializeStorageClassArray (storageArray); ;
28485 1 : assert ( storageClassIndex == sizeOfActualPool );
28486 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeTraitBuiltinOperatorStorageClass ) * sizeOfActualPool) ;
28487 1 : delete [] storageArray;
28488 1 : SgTypeTraitBuiltinOperatorStorageClass :: writeEasyStorageDataToFile(out) ;
28489 : }
28490 :
28491 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgSuperExp );
28492 3 : storageClassIndex = 0 ;
28493 3 : if ( 0 < sizeOfActualPool )
28494 : {
28495 0 : SgSuperExpStorageClass* storageArray = new SgSuperExpStorageClass[sizeOfActualPool] ;
28496 0 : storageClassIndex = SgSuperExp::initializeStorageClassArray (storageArray); ;
28497 0 : assert ( storageClassIndex == sizeOfActualPool );
28498 0 : out.write ( (char*) (storageArray) , sizeof ( SgSuperExpStorageClass ) * sizeOfActualPool) ;
28499 0 : delete [] storageArray;
28500 0 : SgSuperExpStorageClass :: writeEasyStorageDataToFile(out) ;
28501 : }
28502 :
28503 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgThrowOp );
28504 3 : storageClassIndex = 0 ;
28505 3 : if ( 0 < sizeOfActualPool )
28506 : {
28507 53 : SgThrowOpStorageClass* storageArray = new SgThrowOpStorageClass[sizeOfActualPool] ;
28508 1 : storageClassIndex = SgThrowOp::initializeStorageClassArray (storageArray); ;
28509 1 : assert ( storageClassIndex == sizeOfActualPool );
28510 1 : out.write ( (char*) (storageArray) , sizeof ( SgThrowOpStorageClass ) * sizeOfActualPool) ;
28511 1 : delete [] storageArray;
28512 1 : SgThrowOpStorageClass :: writeEasyStorageDataToFile(out) ;
28513 : }
28514 :
28515 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgToken );
28516 3 : storageClassIndex = 0 ;
28517 3 : if ( 0 < sizeOfActualPool )
28518 : {
28519 0 : SgTokenStorageClass* storageArray = new SgTokenStorageClass[sizeOfActualPool] ;
28520 0 : storageClassIndex = SgToken::initializeStorageClassArray (storageArray); ;
28521 0 : assert ( storageClassIndex == sizeOfActualPool );
28522 0 : out.write ( (char*) (storageArray) , sizeof ( SgTokenStorageClass ) * sizeOfActualPool) ;
28523 0 : delete [] storageArray;
28524 0 : SgTokenStorageClass :: writeEasyStorageDataToFile(out) ;
28525 : }
28526 :
28527 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTryStmt );
28528 3 : storageClassIndex = 0 ;
28529 3 : if ( 0 < sizeOfActualPool )
28530 : {
28531 55 : SgTryStmtStorageClass* storageArray = new SgTryStmtStorageClass[sizeOfActualPool] ;
28532 1 : storageClassIndex = SgTryStmt::initializeStorageClassArray (storageArray); ;
28533 1 : assert ( storageClassIndex == sizeOfActualPool );
28534 1 : out.write ( (char*) (storageArray) , sizeof ( SgTryStmtStorageClass ) * sizeOfActualPool) ;
28535 1 : delete [] storageArray;
28536 1 : SgTryStmtStorageClass :: writeEasyStorageDataToFile(out) ;
28537 : }
28538 :
28539 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTupleExp );
28540 3 : storageClassIndex = 0 ;
28541 3 : if ( 0 < sizeOfActualPool )
28542 : {
28543 0 : SgTupleExpStorageClass* storageArray = new SgTupleExpStorageClass[sizeOfActualPool] ;
28544 0 : storageClassIndex = SgTupleExp::initializeStorageClassArray (storageArray); ;
28545 0 : assert ( storageClassIndex == sizeOfActualPool );
28546 0 : out.write ( (char*) (storageArray) , sizeof ( SgTupleExpStorageClass ) * sizeOfActualPool) ;
28547 0 : delete [] storageArray;
28548 0 : SgTupleExpStorageClass :: writeEasyStorageDataToFile(out) ;
28549 : }
28550 :
28551 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgType );
28552 3 : storageClassIndex = 0 ;
28553 3 : if ( 0 < sizeOfActualPool )
28554 : {
28555 0 : SgTypeStorageClass* storageArray = new SgTypeStorageClass[sizeOfActualPool] ;
28556 0 : storageClassIndex = SgType::initializeStorageClassArray (storageArray); ;
28557 0 : assert ( storageClassIndex == sizeOfActualPool );
28558 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeStorageClass ) * sizeOfActualPool) ;
28559 0 : delete [] storageArray;
28560 0 : SgTypeStorageClass :: writeEasyStorageDataToFile(out) ;
28561 : }
28562 :
28563 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeBool );
28564 3 : storageClassIndex = 0 ;
28565 3 : if ( 0 < sizeOfActualPool )
28566 : {
28567 2 : SgTypeBoolStorageClass* storageArray = new SgTypeBoolStorageClass[sizeOfActualPool] ;
28568 1 : storageClassIndex = SgTypeBool::initializeStorageClassArray (storageArray); ;
28569 1 : assert ( storageClassIndex == sizeOfActualPool );
28570 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeBoolStorageClass ) * sizeOfActualPool) ;
28571 1 : delete [] storageArray;
28572 1 : SgTypeBoolStorageClass :: writeEasyStorageDataToFile(out) ;
28573 : }
28574 :
28575 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeChar );
28576 3 : storageClassIndex = 0 ;
28577 3 : if ( 0 < sizeOfActualPool )
28578 : {
28579 4 : SgTypeCharStorageClass* storageArray = new SgTypeCharStorageClass[sizeOfActualPool] ;
28580 2 : storageClassIndex = SgTypeChar::initializeStorageClassArray (storageArray); ;
28581 2 : assert ( storageClassIndex == sizeOfActualPool );
28582 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeCharStorageClass ) * sizeOfActualPool) ;
28583 2 : delete [] storageArray;
28584 2 : SgTypeCharStorageClass :: writeEasyStorageDataToFile(out) ;
28585 : }
28586 :
28587 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeChar16 );
28588 3 : storageClassIndex = 0 ;
28589 3 : if ( 0 < sizeOfActualPool )
28590 : {
28591 2 : SgTypeChar16StorageClass* storageArray = new SgTypeChar16StorageClass[sizeOfActualPool] ;
28592 1 : storageClassIndex = SgTypeChar16::initializeStorageClassArray (storageArray); ;
28593 1 : assert ( storageClassIndex == sizeOfActualPool );
28594 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeChar16StorageClass ) * sizeOfActualPool) ;
28595 1 : delete [] storageArray;
28596 1 : SgTypeChar16StorageClass :: writeEasyStorageDataToFile(out) ;
28597 : }
28598 :
28599 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeChar32 );
28600 3 : storageClassIndex = 0 ;
28601 3 : if ( 0 < sizeOfActualPool )
28602 : {
28603 2 : SgTypeChar32StorageClass* storageArray = new SgTypeChar32StorageClass[sizeOfActualPool] ;
28604 1 : storageClassIndex = SgTypeChar32::initializeStorageClassArray (storageArray); ;
28605 1 : assert ( storageClassIndex == sizeOfActualPool );
28606 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeChar32StorageClass ) * sizeOfActualPool) ;
28607 1 : delete [] storageArray;
28608 1 : SgTypeChar32StorageClass :: writeEasyStorageDataToFile(out) ;
28609 : }
28610 :
28611 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeComplex );
28612 3 : storageClassIndex = 0 ;
28613 3 : if ( 0 < sizeOfActualPool )
28614 : {
28615 9 : SgTypeComplexStorageClass* storageArray = new SgTypeComplexStorageClass[sizeOfActualPool] ;
28616 2 : storageClassIndex = SgTypeComplex::initializeStorageClassArray (storageArray); ;
28617 2 : assert ( storageClassIndex == sizeOfActualPool );
28618 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeComplexStorageClass ) * sizeOfActualPool) ;
28619 2 : delete [] storageArray;
28620 2 : SgTypeComplexStorageClass :: writeEasyStorageDataToFile(out) ;
28621 : }
28622 :
28623 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeDefault );
28624 3 : storageClassIndex = 0 ;
28625 3 : if ( 0 < sizeOfActualPool )
28626 : {
28627 6 : SgTypeDefaultStorageClass* storageArray = new SgTypeDefaultStorageClass[sizeOfActualPool] ;
28628 2 : storageClassIndex = SgTypeDefault::initializeStorageClassArray (storageArray); ;
28629 2 : assert ( storageClassIndex == sizeOfActualPool );
28630 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeDefaultStorageClass ) * sizeOfActualPool) ;
28631 2 : delete [] storageArray;
28632 2 : SgTypeDefaultStorageClass :: writeEasyStorageDataToFile(out) ;
28633 : }
28634 :
28635 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeExpression );
28636 3 : storageClassIndex = 0 ;
28637 3 : if ( 0 < sizeOfActualPool )
28638 : {
28639 0 : SgTypeExpressionStorageClass* storageArray = new SgTypeExpressionStorageClass[sizeOfActualPool] ;
28640 0 : storageClassIndex = SgTypeExpression::initializeStorageClassArray (storageArray); ;
28641 0 : assert ( storageClassIndex == sizeOfActualPool );
28642 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeExpressionStorageClass ) * sizeOfActualPool) ;
28643 0 : delete [] storageArray;
28644 0 : SgTypeExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
28645 : }
28646 :
28647 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeLabel );
28648 3 : storageClassIndex = 0 ;
28649 3 : if ( 0 < sizeOfActualPool )
28650 : {
28651 0 : SgTypeLabelStorageClass* storageArray = new SgTypeLabelStorageClass[sizeOfActualPool] ;
28652 0 : storageClassIndex = SgTypeLabel::initializeStorageClassArray (storageArray); ;
28653 0 : assert ( storageClassIndex == sizeOfActualPool );
28654 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeLabelStorageClass ) * sizeOfActualPool) ;
28655 0 : delete [] storageArray;
28656 0 : SgTypeLabelStorageClass :: writeEasyStorageDataToFile(out) ;
28657 : }
28658 :
28659 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeDouble );
28660 3 : storageClassIndex = 0 ;
28661 3 : if ( 0 < sizeOfActualPool )
28662 : {
28663 4 : SgTypeDoubleStorageClass* storageArray = new SgTypeDoubleStorageClass[sizeOfActualPool] ;
28664 2 : storageClassIndex = SgTypeDouble::initializeStorageClassArray (storageArray); ;
28665 2 : assert ( storageClassIndex == sizeOfActualPool );
28666 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeDoubleStorageClass ) * sizeOfActualPool) ;
28667 2 : delete [] storageArray;
28668 2 : SgTypeDoubleStorageClass :: writeEasyStorageDataToFile(out) ;
28669 : }
28670 :
28671 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeEllipse );
28672 3 : storageClassIndex = 0 ;
28673 3 : if ( 0 < sizeOfActualPool )
28674 : {
28675 4 : SgTypeEllipseStorageClass* storageArray = new SgTypeEllipseStorageClass[sizeOfActualPool] ;
28676 2 : storageClassIndex = SgTypeEllipse::initializeStorageClassArray (storageArray); ;
28677 2 : assert ( storageClassIndex == sizeOfActualPool );
28678 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeEllipseStorageClass ) * sizeOfActualPool) ;
28679 2 : delete [] storageArray;
28680 2 : SgTypeEllipseStorageClass :: writeEasyStorageDataToFile(out) ;
28681 : }
28682 :
28683 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeFixed );
28684 3 : storageClassIndex = 0 ;
28685 3 : if ( 0 < sizeOfActualPool )
28686 : {
28687 0 : SgTypeFixedStorageClass* storageArray = new SgTypeFixedStorageClass[sizeOfActualPool] ;
28688 0 : storageClassIndex = SgTypeFixed::initializeStorageClassArray (storageArray); ;
28689 0 : assert ( storageClassIndex == sizeOfActualPool );
28690 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeFixedStorageClass ) * sizeOfActualPool) ;
28691 0 : delete [] storageArray;
28692 0 : SgTypeFixedStorageClass :: writeEasyStorageDataToFile(out) ;
28693 : }
28694 :
28695 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeFloat );
28696 3 : storageClassIndex = 0 ;
28697 3 : if ( 0 < sizeOfActualPool )
28698 : {
28699 4 : SgTypeFloatStorageClass* storageArray = new SgTypeFloatStorageClass[sizeOfActualPool] ;
28700 2 : storageClassIndex = SgTypeFloat::initializeStorageClassArray (storageArray); ;
28701 2 : assert ( storageClassIndex == sizeOfActualPool );
28702 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeFloatStorageClass ) * sizeOfActualPool) ;
28703 2 : delete [] storageArray;
28704 2 : SgTypeFloatStorageClass :: writeEasyStorageDataToFile(out) ;
28705 : }
28706 :
28707 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeFloat128 );
28708 3 : storageClassIndex = 0 ;
28709 3 : if ( 0 < sizeOfActualPool )
28710 : {
28711 2 : SgTypeFloat128StorageClass* storageArray = new SgTypeFloat128StorageClass[sizeOfActualPool] ;
28712 1 : storageClassIndex = SgTypeFloat128::initializeStorageClassArray (storageArray); ;
28713 1 : assert ( storageClassIndex == sizeOfActualPool );
28714 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeFloat128StorageClass ) * sizeOfActualPool) ;
28715 1 : delete [] storageArray;
28716 1 : SgTypeFloat128StorageClass :: writeEasyStorageDataToFile(out) ;
28717 : }
28718 :
28719 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeFloat80 );
28720 3 : storageClassIndex = 0 ;
28721 3 : if ( 0 < sizeOfActualPool )
28722 : {
28723 0 : SgTypeFloat80StorageClass* storageArray = new SgTypeFloat80StorageClass[sizeOfActualPool] ;
28724 0 : storageClassIndex = SgTypeFloat80::initializeStorageClassArray (storageArray); ;
28725 0 : assert ( storageClassIndex == sizeOfActualPool );
28726 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeFloat80StorageClass ) * sizeOfActualPool) ;
28727 0 : delete [] storageArray;
28728 0 : SgTypeFloat80StorageClass :: writeEasyStorageDataToFile(out) ;
28729 : }
28730 :
28731 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeGlobalVoid );
28732 3 : storageClassIndex = 0 ;
28733 3 : if ( 0 < sizeOfActualPool )
28734 : {
28735 0 : SgTypeGlobalVoidStorageClass* storageArray = new SgTypeGlobalVoidStorageClass[sizeOfActualPool] ;
28736 0 : storageClassIndex = SgTypeGlobalVoid::initializeStorageClassArray (storageArray); ;
28737 0 : assert ( storageClassIndex == sizeOfActualPool );
28738 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeGlobalVoidStorageClass ) * sizeOfActualPool) ;
28739 0 : delete [] storageArray;
28740 0 : SgTypeGlobalVoidStorageClass :: writeEasyStorageDataToFile(out) ;
28741 : }
28742 :
28743 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeIdOp );
28744 3 : storageClassIndex = 0 ;
28745 3 : if ( 0 < sizeOfActualPool )
28746 : {
28747 2 : SgTypeIdOpStorageClass* storageArray = new SgTypeIdOpStorageClass[sizeOfActualPool] ;
28748 1 : storageClassIndex = SgTypeIdOp::initializeStorageClassArray (storageArray); ;
28749 1 : assert ( storageClassIndex == sizeOfActualPool );
28750 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeIdOpStorageClass ) * sizeOfActualPool) ;
28751 1 : delete [] storageArray;
28752 1 : SgTypeIdOpStorageClass :: writeEasyStorageDataToFile(out) ;
28753 : }
28754 :
28755 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeImaginary );
28756 3 : storageClassIndex = 0 ;
28757 3 : if ( 0 < sizeOfActualPool )
28758 : {
28759 0 : SgTypeImaginaryStorageClass* storageArray = new SgTypeImaginaryStorageClass[sizeOfActualPool] ;
28760 0 : storageClassIndex = SgTypeImaginary::initializeStorageClassArray (storageArray); ;
28761 0 : assert ( storageClassIndex == sizeOfActualPool );
28762 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeImaginaryStorageClass ) * sizeOfActualPool) ;
28763 0 : delete [] storageArray;
28764 0 : SgTypeImaginaryStorageClass :: writeEasyStorageDataToFile(out) ;
28765 : }
28766 :
28767 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeInt );
28768 3 : storageClassIndex = 0 ;
28769 3 : if ( 0 < sizeOfActualPool )
28770 : {
28771 4 : SgTypeIntStorageClass* storageArray = new SgTypeIntStorageClass[sizeOfActualPool] ;
28772 2 : storageClassIndex = SgTypeInt::initializeStorageClassArray (storageArray); ;
28773 2 : assert ( storageClassIndex == sizeOfActualPool );
28774 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeIntStorageClass ) * sizeOfActualPool) ;
28775 2 : delete [] storageArray;
28776 2 : SgTypeIntStorageClass :: writeEasyStorageDataToFile(out) ;
28777 : }
28778 :
28779 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeLong );
28780 3 : storageClassIndex = 0 ;
28781 3 : if ( 0 < sizeOfActualPool )
28782 : {
28783 4 : SgTypeLongStorageClass* storageArray = new SgTypeLongStorageClass[sizeOfActualPool] ;
28784 2 : storageClassIndex = SgTypeLong::initializeStorageClassArray (storageArray); ;
28785 2 : assert ( storageClassIndex == sizeOfActualPool );
28786 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeLongStorageClass ) * sizeOfActualPool) ;
28787 2 : delete [] storageArray;
28788 2 : SgTypeLongStorageClass :: writeEasyStorageDataToFile(out) ;
28789 : }
28790 :
28791 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeLongDouble );
28792 3 : storageClassIndex = 0 ;
28793 3 : if ( 0 < sizeOfActualPool )
28794 : {
28795 4 : SgTypeLongDoubleStorageClass* storageArray = new SgTypeLongDoubleStorageClass[sizeOfActualPool] ;
28796 2 : storageClassIndex = SgTypeLongDouble::initializeStorageClassArray (storageArray); ;
28797 2 : assert ( storageClassIndex == sizeOfActualPool );
28798 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeLongDoubleStorageClass ) * sizeOfActualPool) ;
28799 2 : delete [] storageArray;
28800 2 : SgTypeLongDoubleStorageClass :: writeEasyStorageDataToFile(out) ;
28801 : }
28802 :
28803 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeLongLong );
28804 3 : storageClassIndex = 0 ;
28805 3 : if ( 0 < sizeOfActualPool )
28806 : {
28807 4 : SgTypeLongLongStorageClass* storageArray = new SgTypeLongLongStorageClass[sizeOfActualPool] ;
28808 2 : storageClassIndex = SgTypeLongLong::initializeStorageClassArray (storageArray); ;
28809 2 : assert ( storageClassIndex == sizeOfActualPool );
28810 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeLongLongStorageClass ) * sizeOfActualPool) ;
28811 2 : delete [] storageArray;
28812 2 : SgTypeLongLongStorageClass :: writeEasyStorageDataToFile(out) ;
28813 : }
28814 :
28815 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeModifier );
28816 3 : storageClassIndex = 0 ;
28817 3 : if ( 0 < sizeOfActualPool )
28818 : {
28819 0 : SgTypeModifierStorageClass* storageArray = new SgTypeModifierStorageClass[sizeOfActualPool] ;
28820 0 : storageClassIndex = SgTypeModifier::initializeStorageClassArray (storageArray); ;
28821 0 : assert ( storageClassIndex == sizeOfActualPool );
28822 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeModifierStorageClass ) * sizeOfActualPool) ;
28823 0 : delete [] storageArray;
28824 0 : SgTypeModifierStorageClass :: writeEasyStorageDataToFile(out) ;
28825 : }
28826 :
28827 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeMatrix );
28828 3 : storageClassIndex = 0 ;
28829 3 : if ( 0 < sizeOfActualPool )
28830 : {
28831 0 : SgTypeMatrixStorageClass* storageArray = new SgTypeMatrixStorageClass[sizeOfActualPool] ;
28832 0 : storageClassIndex = SgTypeMatrix::initializeStorageClassArray (storageArray); ;
28833 0 : assert ( storageClassIndex == sizeOfActualPool );
28834 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeMatrixStorageClass ) * sizeOfActualPool) ;
28835 0 : delete [] storageArray;
28836 0 : SgTypeMatrixStorageClass :: writeEasyStorageDataToFile(out) ;
28837 : }
28838 :
28839 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeTuple );
28840 3 : storageClassIndex = 0 ;
28841 3 : if ( 0 < sizeOfActualPool )
28842 : {
28843 0 : SgTypeTupleStorageClass* storageArray = new SgTypeTupleStorageClass[sizeOfActualPool] ;
28844 0 : storageClassIndex = SgTypeTuple::initializeStorageClassArray (storageArray); ;
28845 0 : assert ( storageClassIndex == sizeOfActualPool );
28846 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeTupleStorageClass ) * sizeOfActualPool) ;
28847 0 : delete [] storageArray;
28848 0 : SgTypeTupleStorageClass :: writeEasyStorageDataToFile(out) ;
28849 : }
28850 :
28851 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeNullptr );
28852 3 : storageClassIndex = 0 ;
28853 3 : if ( 0 < sizeOfActualPool )
28854 : {
28855 2 : SgTypeNullptrStorageClass* storageArray = new SgTypeNullptrStorageClass[sizeOfActualPool] ;
28856 1 : storageClassIndex = SgTypeNullptr::initializeStorageClassArray (storageArray); ;
28857 1 : assert ( storageClassIndex == sizeOfActualPool );
28858 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeNullptrStorageClass ) * sizeOfActualPool) ;
28859 1 : delete [] storageArray;
28860 1 : SgTypeNullptrStorageClass :: writeEasyStorageDataToFile(out) ;
28861 : }
28862 :
28863 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeOfType );
28864 3 : storageClassIndex = 0 ;
28865 3 : if ( 0 < sizeOfActualPool )
28866 : {
28867 4 : SgTypeOfTypeStorageClass* storageArray = new SgTypeOfTypeStorageClass[sizeOfActualPool] ;
28868 1 : storageClassIndex = SgTypeOfType::initializeStorageClassArray (storageArray); ;
28869 1 : assert ( storageClassIndex == sizeOfActualPool );
28870 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeOfTypeStorageClass ) * sizeOfActualPool) ;
28871 1 : delete [] storageArray;
28872 1 : SgTypeOfTypeStorageClass :: writeEasyStorageDataToFile(out) ;
28873 : }
28874 :
28875 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeShort );
28876 3 : storageClassIndex = 0 ;
28877 3 : if ( 0 < sizeOfActualPool )
28878 : {
28879 4 : SgTypeShortStorageClass* storageArray = new SgTypeShortStorageClass[sizeOfActualPool] ;
28880 2 : storageClassIndex = SgTypeShort::initializeStorageClassArray (storageArray); ;
28881 2 : assert ( storageClassIndex == sizeOfActualPool );
28882 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeShortStorageClass ) * sizeOfActualPool) ;
28883 2 : delete [] storageArray;
28884 2 : SgTypeShortStorageClass :: writeEasyStorageDataToFile(out) ;
28885 : }
28886 :
28887 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSigned128bitInteger );
28888 3 : storageClassIndex = 0 ;
28889 3 : if ( 0 < sizeOfActualPool )
28890 : {
28891 2 : SgTypeSigned128bitIntegerStorageClass* storageArray = new SgTypeSigned128bitIntegerStorageClass[sizeOfActualPool] ;
28892 1 : storageClassIndex = SgTypeSigned128bitInteger::initializeStorageClassArray (storageArray); ;
28893 1 : assert ( storageClassIndex == sizeOfActualPool );
28894 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSigned128bitIntegerStorageClass ) * sizeOfActualPool) ;
28895 1 : delete [] storageArray;
28896 1 : SgTypeSigned128bitIntegerStorageClass :: writeEasyStorageDataToFile(out) ;
28897 : }
28898 :
28899 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSignedChar );
28900 3 : storageClassIndex = 0 ;
28901 3 : if ( 0 < sizeOfActualPool )
28902 : {
28903 4 : SgTypeSignedCharStorageClass* storageArray = new SgTypeSignedCharStorageClass[sizeOfActualPool] ;
28904 2 : storageClassIndex = SgTypeSignedChar::initializeStorageClassArray (storageArray); ;
28905 2 : assert ( storageClassIndex == sizeOfActualPool );
28906 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSignedCharStorageClass ) * sizeOfActualPool) ;
28907 2 : delete [] storageArray;
28908 2 : SgTypeSignedCharStorageClass :: writeEasyStorageDataToFile(out) ;
28909 : }
28910 :
28911 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSignedInt );
28912 3 : storageClassIndex = 0 ;
28913 3 : if ( 0 < sizeOfActualPool )
28914 : {
28915 4 : SgTypeSignedIntStorageClass* storageArray = new SgTypeSignedIntStorageClass[sizeOfActualPool] ;
28916 2 : storageClassIndex = SgTypeSignedInt::initializeStorageClassArray (storageArray); ;
28917 2 : assert ( storageClassIndex == sizeOfActualPool );
28918 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSignedIntStorageClass ) * sizeOfActualPool) ;
28919 2 : delete [] storageArray;
28920 2 : SgTypeSignedIntStorageClass :: writeEasyStorageDataToFile(out) ;
28921 : }
28922 :
28923 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSignedLong );
28924 3 : storageClassIndex = 0 ;
28925 3 : if ( 0 < sizeOfActualPool )
28926 : {
28927 4 : SgTypeSignedLongStorageClass* storageArray = new SgTypeSignedLongStorageClass[sizeOfActualPool] ;
28928 2 : storageClassIndex = SgTypeSignedLong::initializeStorageClassArray (storageArray); ;
28929 2 : assert ( storageClassIndex == sizeOfActualPool );
28930 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSignedLongStorageClass ) * sizeOfActualPool) ;
28931 2 : delete [] storageArray;
28932 2 : SgTypeSignedLongStorageClass :: writeEasyStorageDataToFile(out) ;
28933 : }
28934 :
28935 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSignedLongLong );
28936 3 : storageClassIndex = 0 ;
28937 3 : if ( 0 < sizeOfActualPool )
28938 : {
28939 2 : SgTypeSignedLongLongStorageClass* storageArray = new SgTypeSignedLongLongStorageClass[sizeOfActualPool] ;
28940 1 : storageClassIndex = SgTypeSignedLongLong::initializeStorageClassArray (storageArray); ;
28941 1 : assert ( storageClassIndex == sizeOfActualPool );
28942 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSignedLongLongStorageClass ) * sizeOfActualPool) ;
28943 1 : delete [] storageArray;
28944 1 : SgTypeSignedLongLongStorageClass :: writeEasyStorageDataToFile(out) ;
28945 : }
28946 :
28947 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeSignedShort );
28948 3 : storageClassIndex = 0 ;
28949 3 : if ( 0 < sizeOfActualPool )
28950 : {
28951 4 : SgTypeSignedShortStorageClass* storageArray = new SgTypeSignedShortStorageClass[sizeOfActualPool] ;
28952 2 : storageClassIndex = SgTypeSignedShort::initializeStorageClassArray (storageArray); ;
28953 2 : assert ( storageClassIndex == sizeOfActualPool );
28954 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeSignedShortStorageClass ) * sizeOfActualPool) ;
28955 2 : delete [] storageArray;
28956 2 : SgTypeSignedShortStorageClass :: writeEasyStorageDataToFile(out) ;
28957 : }
28958 :
28959 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeString );
28960 3 : storageClassIndex = 0 ;
28961 3 : if ( 0 < sizeOfActualPool )
28962 : {
28963 0 : SgTypeStringStorageClass* storageArray = new SgTypeStringStorageClass[sizeOfActualPool] ;
28964 0 : storageClassIndex = SgTypeString::initializeStorageClassArray (storageArray); ;
28965 0 : assert ( storageClassIndex == sizeOfActualPool );
28966 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeStringStorageClass ) * sizeOfActualPool) ;
28967 0 : delete [] storageArray;
28968 0 : SgTypeStringStorageClass :: writeEasyStorageDataToFile(out) ;
28969 : }
28970 :
28971 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnknown );
28972 3 : storageClassIndex = 0 ;
28973 3 : if ( 0 < sizeOfActualPool )
28974 : {
28975 2 : SgTypeUnknownStorageClass* storageArray = new SgTypeUnknownStorageClass[sizeOfActualPool] ;
28976 1 : storageClassIndex = SgTypeUnknown::initializeStorageClassArray (storageArray); ;
28977 1 : assert ( storageClassIndex == sizeOfActualPool );
28978 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnknownStorageClass ) * sizeOfActualPool) ;
28979 1 : delete [] storageArray;
28980 1 : SgTypeUnknownStorageClass :: writeEasyStorageDataToFile(out) ;
28981 : }
28982 :
28983 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsigned128bitInteger );
28984 3 : storageClassIndex = 0 ;
28985 3 : if ( 0 < sizeOfActualPool )
28986 : {
28987 2 : SgTypeUnsigned128bitIntegerStorageClass* storageArray = new SgTypeUnsigned128bitIntegerStorageClass[sizeOfActualPool] ;
28988 1 : storageClassIndex = SgTypeUnsigned128bitInteger::initializeStorageClassArray (storageArray); ;
28989 1 : assert ( storageClassIndex == sizeOfActualPool );
28990 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsigned128bitIntegerStorageClass ) * sizeOfActualPool) ;
28991 1 : delete [] storageArray;
28992 1 : SgTypeUnsigned128bitIntegerStorageClass :: writeEasyStorageDataToFile(out) ;
28993 : }
28994 :
28995 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsignedChar );
28996 3 : storageClassIndex = 0 ;
28997 3 : if ( 0 < sizeOfActualPool )
28998 : {
28999 4 : SgTypeUnsignedCharStorageClass* storageArray = new SgTypeUnsignedCharStorageClass[sizeOfActualPool] ;
29000 2 : storageClassIndex = SgTypeUnsignedChar::initializeStorageClassArray (storageArray); ;
29001 2 : assert ( storageClassIndex == sizeOfActualPool );
29002 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsignedCharStorageClass ) * sizeOfActualPool) ;
29003 2 : delete [] storageArray;
29004 2 : SgTypeUnsignedCharStorageClass :: writeEasyStorageDataToFile(out) ;
29005 : }
29006 :
29007 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsignedInt );
29008 3 : storageClassIndex = 0 ;
29009 3 : if ( 0 < sizeOfActualPool )
29010 : {
29011 4 : SgTypeUnsignedIntStorageClass* storageArray = new SgTypeUnsignedIntStorageClass[sizeOfActualPool] ;
29012 2 : storageClassIndex = SgTypeUnsignedInt::initializeStorageClassArray (storageArray); ;
29013 2 : assert ( storageClassIndex == sizeOfActualPool );
29014 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsignedIntStorageClass ) * sizeOfActualPool) ;
29015 2 : delete [] storageArray;
29016 2 : SgTypeUnsignedIntStorageClass :: writeEasyStorageDataToFile(out) ;
29017 : }
29018 :
29019 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsignedLong );
29020 3 : storageClassIndex = 0 ;
29021 3 : if ( 0 < sizeOfActualPool )
29022 : {
29023 4 : SgTypeUnsignedLongStorageClass* storageArray = new SgTypeUnsignedLongStorageClass[sizeOfActualPool] ;
29024 2 : storageClassIndex = SgTypeUnsignedLong::initializeStorageClassArray (storageArray); ;
29025 2 : assert ( storageClassIndex == sizeOfActualPool );
29026 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsignedLongStorageClass ) * sizeOfActualPool) ;
29027 2 : delete [] storageArray;
29028 2 : SgTypeUnsignedLongStorageClass :: writeEasyStorageDataToFile(out) ;
29029 : }
29030 :
29031 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsignedLongLong );
29032 3 : storageClassIndex = 0 ;
29033 3 : if ( 0 < sizeOfActualPool )
29034 : {
29035 4 : SgTypeUnsignedLongLongStorageClass* storageArray = new SgTypeUnsignedLongLongStorageClass[sizeOfActualPool] ;
29036 2 : storageClassIndex = SgTypeUnsignedLongLong::initializeStorageClassArray (storageArray); ;
29037 2 : assert ( storageClassIndex == sizeOfActualPool );
29038 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsignedLongLongStorageClass ) * sizeOfActualPool) ;
29039 2 : delete [] storageArray;
29040 2 : SgTypeUnsignedLongLongStorageClass :: writeEasyStorageDataToFile(out) ;
29041 : }
29042 :
29043 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeUnsignedShort );
29044 3 : storageClassIndex = 0 ;
29045 3 : if ( 0 < sizeOfActualPool )
29046 : {
29047 4 : SgTypeUnsignedShortStorageClass* storageArray = new SgTypeUnsignedShortStorageClass[sizeOfActualPool] ;
29048 2 : storageClassIndex = SgTypeUnsignedShort::initializeStorageClassArray (storageArray); ;
29049 2 : assert ( storageClassIndex == sizeOfActualPool );
29050 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypeUnsignedShortStorageClass ) * sizeOfActualPool) ;
29051 2 : delete [] storageArray;
29052 2 : SgTypeUnsignedShortStorageClass :: writeEasyStorageDataToFile(out) ;
29053 : }
29054 :
29055 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeVoid );
29056 3 : storageClassIndex = 0 ;
29057 3 : if ( 0 < sizeOfActualPool )
29058 : {
29059 6 : SgTypeVoidStorageClass* storageArray = new SgTypeVoidStorageClass[sizeOfActualPool] ;
29060 3 : storageClassIndex = SgTypeVoid::initializeStorageClassArray (storageArray); ;
29061 3 : assert ( storageClassIndex == sizeOfActualPool );
29062 3 : out.write ( (char*) (storageArray) , sizeof ( SgTypeVoidStorageClass ) * sizeOfActualPool) ;
29063 3 : delete [] storageArray;
29064 3 : SgTypeVoidStorageClass :: writeEasyStorageDataToFile(out) ;
29065 : }
29066 :
29067 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeWchar );
29068 3 : storageClassIndex = 0 ;
29069 3 : if ( 0 < sizeOfActualPool )
29070 : {
29071 2 : SgTypeWcharStorageClass* storageArray = new SgTypeWcharStorageClass[sizeOfActualPool] ;
29072 1 : storageClassIndex = SgTypeWchar::initializeStorageClassArray (storageArray); ;
29073 1 : assert ( storageClassIndex == sizeOfActualPool );
29074 1 : out.write ( (char*) (storageArray) , sizeof ( SgTypeWcharStorageClass ) * sizeOfActualPool) ;
29075 1 : delete [] storageArray;
29076 1 : SgTypeWcharStorageClass :: writeEasyStorageDataToFile(out) ;
29077 : }
29078 :
29079 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypedefDeclaration );
29080 3 : storageClassIndex = 0 ;
29081 3 : if ( 0 < sizeOfActualPool )
29082 : {
29083 1721 : SgTypedefDeclarationStorageClass* storageArray = new SgTypedefDeclarationStorageClass[sizeOfActualPool] ;
29084 2 : storageClassIndex = SgTypedefDeclaration::initializeStorageClassArray (storageArray); ;
29085 2 : assert ( storageClassIndex == sizeOfActualPool );
29086 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
29087 2 : delete [] storageArray;
29088 2 : SgTypedefDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
29089 : }
29090 :
29091 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypedefSeq );
29092 3 : storageClassIndex = 0 ;
29093 3 : if ( 0 < sizeOfActualPool )
29094 : {
29095 16450 : SgTypedefSeqStorageClass* storageArray = new SgTypedefSeqStorageClass[sizeOfActualPool] ;
29096 3 : storageClassIndex = SgTypedefSeq::initializeStorageClassArray (storageArray); ;
29097 3 : assert ( storageClassIndex == sizeOfActualPool );
29098 3 : out.write ( (char*) (storageArray) , sizeof ( SgTypedefSeqStorageClass ) * sizeOfActualPool) ;
29099 3 : delete [] storageArray;
29100 3 : SgTypedefSeqStorageClass :: writeEasyStorageDataToFile(out) ;
29101 : }
29102 :
29103 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypedefSymbol );
29104 3 : storageClassIndex = 0 ;
29105 3 : if ( 0 < sizeOfActualPool )
29106 : {
29107 1721 : SgTypedefSymbolStorageClass* storageArray = new SgTypedefSymbolStorageClass[sizeOfActualPool] ;
29108 2 : storageClassIndex = SgTypedefSymbol::initializeStorageClassArray (storageArray); ;
29109 2 : assert ( storageClassIndex == sizeOfActualPool );
29110 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypedefSymbolStorageClass ) * sizeOfActualPool) ;
29111 2 : delete [] storageArray;
29112 2 : SgTypedefSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
29113 : }
29114 :
29115 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypedefType );
29116 3 : storageClassIndex = 0 ;
29117 3 : if ( 0 < sizeOfActualPool )
29118 : {
29119 1850 : SgTypedefTypeStorageClass* storageArray = new SgTypedefTypeStorageClass[sizeOfActualPool] ;
29120 2 : storageClassIndex = SgTypedefType::initializeStorageClassArray (storageArray); ;
29121 2 : assert ( storageClassIndex == sizeOfActualPool );
29122 2 : out.write ( (char*) (storageArray) , sizeof ( SgTypedefTypeStorageClass ) * sizeOfActualPool) ;
29123 2 : delete [] storageArray;
29124 2 : SgTypedefTypeStorageClass :: writeEasyStorageDataToFile(out) ;
29125 : }
29126 :
29127 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUPC_AccessModifier );
29128 3 : storageClassIndex = 0 ;
29129 3 : if ( 0 < sizeOfActualPool )
29130 : {
29131 0 : SgUPC_AccessModifierStorageClass* storageArray = new SgUPC_AccessModifierStorageClass[sizeOfActualPool] ;
29132 0 : storageClassIndex = SgUPC_AccessModifier::initializeStorageClassArray (storageArray); ;
29133 0 : assert ( storageClassIndex == sizeOfActualPool );
29134 0 : out.write ( (char*) (storageArray) , sizeof ( SgUPC_AccessModifierStorageClass ) * sizeOfActualPool) ;
29135 0 : delete [] storageArray;
29136 : }
29137 :
29138 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnaryAddOp );
29139 3 : storageClassIndex = 0 ;
29140 3 : if ( 0 < sizeOfActualPool )
29141 : {
29142 0 : SgUnaryAddOpStorageClass* storageArray = new SgUnaryAddOpStorageClass[sizeOfActualPool] ;
29143 0 : storageClassIndex = SgUnaryAddOp::initializeStorageClassArray (storageArray); ;
29144 0 : assert ( storageClassIndex == sizeOfActualPool );
29145 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnaryAddOpStorageClass ) * sizeOfActualPool) ;
29146 0 : delete [] storageArray;
29147 0 : SgUnaryAddOpStorageClass :: writeEasyStorageDataToFile(out) ;
29148 : }
29149 :
29150 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnaryOp );
29151 3 : storageClassIndex = 0 ;
29152 3 : if ( 0 < sizeOfActualPool )
29153 : {
29154 0 : SgUnaryOpStorageClass* storageArray = new SgUnaryOpStorageClass[sizeOfActualPool] ;
29155 0 : storageClassIndex = SgUnaryOp::initializeStorageClassArray (storageArray); ;
29156 0 : assert ( storageClassIndex == sizeOfActualPool );
29157 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnaryOpStorageClass ) * sizeOfActualPool) ;
29158 0 : delete [] storageArray;
29159 0 : SgUnaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
29160 : }
29161 :
29162 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUndefDirectiveStatement );
29163 3 : storageClassIndex = 0 ;
29164 3 : if ( 0 < sizeOfActualPool )
29165 : {
29166 0 : SgUndefDirectiveStatementStorageClass* storageArray = new SgUndefDirectiveStatementStorageClass[sizeOfActualPool] ;
29167 0 : storageClassIndex = SgUndefDirectiveStatement::initializeStorageClassArray (storageArray); ;
29168 0 : assert ( storageClassIndex == sizeOfActualPool );
29169 0 : out.write ( (char*) (storageArray) , sizeof ( SgUndefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
29170 0 : delete [] storageArray;
29171 0 : SgUndefDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29172 : }
29173 :
29174 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUndirectedGraphEdge );
29175 3 : storageClassIndex = 0 ;
29176 3 : if ( 0 < sizeOfActualPool )
29177 : {
29178 0 : SgUndirectedGraphEdgeStorageClass* storageArray = new SgUndirectedGraphEdgeStorageClass[sizeOfActualPool] ;
29179 0 : storageClassIndex = SgUndirectedGraphEdge::initializeStorageClassArray (storageArray); ;
29180 0 : assert ( storageClassIndex == sizeOfActualPool );
29181 0 : out.write ( (char*) (storageArray) , sizeof ( SgUndirectedGraphEdgeStorageClass ) * sizeOfActualPool) ;
29182 0 : delete [] storageArray;
29183 0 : SgUndirectedGraphEdgeStorageClass :: writeEasyStorageDataToFile(out) ;
29184 : }
29185 :
29186 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnknownArrayOrFunctionReference );
29187 3 : storageClassIndex = 0 ;
29188 3 : if ( 0 < sizeOfActualPool )
29189 : {
29190 0 : SgUnknownArrayOrFunctionReferenceStorageClass* storageArray = new SgUnknownArrayOrFunctionReferenceStorageClass[sizeOfActualPool] ;
29191 0 : storageClassIndex = SgUnknownArrayOrFunctionReference::initializeStorageClassArray (storageArray); ;
29192 0 : assert ( storageClassIndex == sizeOfActualPool );
29193 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnknownArrayOrFunctionReferenceStorageClass ) * sizeOfActualPool) ;
29194 0 : delete [] storageArray;
29195 0 : SgUnknownArrayOrFunctionReferenceStorageClass :: writeEasyStorageDataToFile(out) ;
29196 : }
29197 :
29198 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnknownFile );
29199 3 : storageClassIndex = 0 ;
29200 3 : if ( 0 < sizeOfActualPool )
29201 : {
29202 0 : SgUnknownFileStorageClass* storageArray = new SgUnknownFileStorageClass[sizeOfActualPool] ;
29203 0 : storageClassIndex = SgUnknownFile::initializeStorageClassArray (storageArray); ;
29204 0 : assert ( storageClassIndex == sizeOfActualPool );
29205 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnknownFileStorageClass ) * sizeOfActualPool) ;
29206 0 : delete [] storageArray;
29207 0 : SgUnknownFileStorageClass :: writeEasyStorageDataToFile(out) ;
29208 : }
29209 :
29210 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnparse_Info );
29211 3 : storageClassIndex = 0 ;
29212 3 : if ( 0 < sizeOfActualPool )
29213 : {
29214 0 : SgUnparse_InfoStorageClass* storageArray = new SgUnparse_InfoStorageClass[sizeOfActualPool] ;
29215 0 : storageClassIndex = SgUnparse_Info::initializeStorageClassArray (storageArray); ;
29216 0 : assert ( storageClassIndex == sizeOfActualPool );
29217 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnparse_InfoStorageClass ) * sizeOfActualPool) ;
29218 0 : delete [] storageArray;
29219 0 : SgUnparse_InfoStorageClass :: writeEasyStorageDataToFile(out) ;
29220 : }
29221 :
29222 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnsignedCharVal );
29223 3 : storageClassIndex = 0 ;
29224 3 : if ( 0 < sizeOfActualPool )
29225 : {
29226 0 : SgUnsignedCharValStorageClass* storageArray = new SgUnsignedCharValStorageClass[sizeOfActualPool] ;
29227 0 : storageClassIndex = SgUnsignedCharVal::initializeStorageClassArray (storageArray); ;
29228 0 : assert ( storageClassIndex == sizeOfActualPool );
29229 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnsignedCharValStorageClass ) * sizeOfActualPool) ;
29230 0 : delete [] storageArray;
29231 0 : SgUnsignedCharValStorageClass :: writeEasyStorageDataToFile(out) ;
29232 : }
29233 :
29234 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnsignedIntVal );
29235 3 : storageClassIndex = 0 ;
29236 3 : if ( 0 < sizeOfActualPool )
29237 : {
29238 9 : SgUnsignedIntValStorageClass* storageArray = new SgUnsignedIntValStorageClass[sizeOfActualPool] ;
29239 1 : storageClassIndex = SgUnsignedIntVal::initializeStorageClassArray (storageArray); ;
29240 1 : assert ( storageClassIndex == sizeOfActualPool );
29241 1 : out.write ( (char*) (storageArray) , sizeof ( SgUnsignedIntValStorageClass ) * sizeOfActualPool) ;
29242 1 : delete [] storageArray;
29243 1 : SgUnsignedIntValStorageClass :: writeEasyStorageDataToFile(out) ;
29244 : }
29245 :
29246 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnsignedLongLongIntVal );
29247 3 : storageClassIndex = 0 ;
29248 3 : if ( 0 < sizeOfActualPool )
29249 : {
29250 0 : SgUnsignedLongLongIntValStorageClass* storageArray = new SgUnsignedLongLongIntValStorageClass[sizeOfActualPool] ;
29251 0 : storageClassIndex = SgUnsignedLongLongIntVal::initializeStorageClassArray (storageArray); ;
29252 0 : assert ( storageClassIndex == sizeOfActualPool );
29253 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnsignedLongLongIntValStorageClass ) * sizeOfActualPool) ;
29254 0 : delete [] storageArray;
29255 0 : SgUnsignedLongLongIntValStorageClass :: writeEasyStorageDataToFile(out) ;
29256 : }
29257 :
29258 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnsignedLongVal );
29259 3 : storageClassIndex = 0 ;
29260 3 : if ( 0 < sizeOfActualPool )
29261 : {
29262 20 : SgUnsignedLongValStorageClass* storageArray = new SgUnsignedLongValStorageClass[sizeOfActualPool] ;
29263 1 : storageClassIndex = SgUnsignedLongVal::initializeStorageClassArray (storageArray); ;
29264 1 : assert ( storageClassIndex == sizeOfActualPool );
29265 1 : out.write ( (char*) (storageArray) , sizeof ( SgUnsignedLongValStorageClass ) * sizeOfActualPool) ;
29266 1 : delete [] storageArray;
29267 1 : SgUnsignedLongValStorageClass :: writeEasyStorageDataToFile(out) ;
29268 : }
29269 :
29270 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUnsignedShortVal );
29271 3 : storageClassIndex = 0 ;
29272 3 : if ( 0 < sizeOfActualPool )
29273 : {
29274 0 : SgUnsignedShortValStorageClass* storageArray = new SgUnsignedShortValStorageClass[sizeOfActualPool] ;
29275 0 : storageClassIndex = SgUnsignedShortVal::initializeStorageClassArray (storageArray); ;
29276 0 : assert ( storageClassIndex == sizeOfActualPool );
29277 0 : out.write ( (char*) (storageArray) , sizeof ( SgUnsignedShortValStorageClass ) * sizeOfActualPool) ;
29278 0 : delete [] storageArray;
29279 0 : SgUnsignedShortValStorageClass :: writeEasyStorageDataToFile(out) ;
29280 : }
29281 :
29282 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcBarrierStatement );
29283 3 : storageClassIndex = 0 ;
29284 3 : if ( 0 < sizeOfActualPool )
29285 : {
29286 0 : SgUpcBarrierStatementStorageClass* storageArray = new SgUpcBarrierStatementStorageClass[sizeOfActualPool] ;
29287 0 : storageClassIndex = SgUpcBarrierStatement::initializeStorageClassArray (storageArray); ;
29288 0 : assert ( storageClassIndex == sizeOfActualPool );
29289 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcBarrierStatementStorageClass ) * sizeOfActualPool) ;
29290 0 : delete [] storageArray;
29291 0 : SgUpcBarrierStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29292 : }
29293 :
29294 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcBlocksizeofExpression );
29295 3 : storageClassIndex = 0 ;
29296 3 : if ( 0 < sizeOfActualPool )
29297 : {
29298 0 : SgUpcBlocksizeofExpressionStorageClass* storageArray = new SgUpcBlocksizeofExpressionStorageClass[sizeOfActualPool] ;
29299 0 : storageClassIndex = SgUpcBlocksizeofExpression::initializeStorageClassArray (storageArray); ;
29300 0 : assert ( storageClassIndex == sizeOfActualPool );
29301 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcBlocksizeofExpressionStorageClass ) * sizeOfActualPool) ;
29302 0 : delete [] storageArray;
29303 0 : SgUpcBlocksizeofExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29304 : }
29305 :
29306 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcElemsizeofExpression );
29307 3 : storageClassIndex = 0 ;
29308 3 : if ( 0 < sizeOfActualPool )
29309 : {
29310 0 : SgUpcElemsizeofExpressionStorageClass* storageArray = new SgUpcElemsizeofExpressionStorageClass[sizeOfActualPool] ;
29311 0 : storageClassIndex = SgUpcElemsizeofExpression::initializeStorageClassArray (storageArray); ;
29312 0 : assert ( storageClassIndex == sizeOfActualPool );
29313 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcElemsizeofExpressionStorageClass ) * sizeOfActualPool) ;
29314 0 : delete [] storageArray;
29315 0 : SgUpcElemsizeofExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29316 : }
29317 :
29318 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcFenceStatement );
29319 3 : storageClassIndex = 0 ;
29320 3 : if ( 0 < sizeOfActualPool )
29321 : {
29322 0 : SgUpcFenceStatementStorageClass* storageArray = new SgUpcFenceStatementStorageClass[sizeOfActualPool] ;
29323 0 : storageClassIndex = SgUpcFenceStatement::initializeStorageClassArray (storageArray); ;
29324 0 : assert ( storageClassIndex == sizeOfActualPool );
29325 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcFenceStatementStorageClass ) * sizeOfActualPool) ;
29326 0 : delete [] storageArray;
29327 0 : SgUpcFenceStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29328 : }
29329 :
29330 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcForAllStatement );
29331 3 : storageClassIndex = 0 ;
29332 3 : if ( 0 < sizeOfActualPool )
29333 : {
29334 0 : SgUpcForAllStatementStorageClass* storageArray = new SgUpcForAllStatementStorageClass[sizeOfActualPool] ;
29335 0 : storageClassIndex = SgUpcForAllStatement::initializeStorageClassArray (storageArray); ;
29336 0 : assert ( storageClassIndex == sizeOfActualPool );
29337 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcForAllStatementStorageClass ) * sizeOfActualPool) ;
29338 0 : delete [] storageArray;
29339 0 : SgUpcForAllStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29340 : }
29341 :
29342 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcLocalsizeofExpression );
29343 3 : storageClassIndex = 0 ;
29344 3 : if ( 0 < sizeOfActualPool )
29345 : {
29346 0 : SgUpcLocalsizeofExpressionStorageClass* storageArray = new SgUpcLocalsizeofExpressionStorageClass[sizeOfActualPool] ;
29347 0 : storageClassIndex = SgUpcLocalsizeofExpression::initializeStorageClassArray (storageArray); ;
29348 0 : assert ( storageClassIndex == sizeOfActualPool );
29349 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcLocalsizeofExpressionStorageClass ) * sizeOfActualPool) ;
29350 0 : delete [] storageArray;
29351 0 : SgUpcLocalsizeofExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29352 : }
29353 :
29354 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcMythread );
29355 3 : storageClassIndex = 0 ;
29356 3 : if ( 0 < sizeOfActualPool )
29357 : {
29358 0 : SgUpcMythreadStorageClass* storageArray = new SgUpcMythreadStorageClass[sizeOfActualPool] ;
29359 0 : storageClassIndex = SgUpcMythread::initializeStorageClassArray (storageArray); ;
29360 0 : assert ( storageClassIndex == sizeOfActualPool );
29361 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcMythreadStorageClass ) * sizeOfActualPool) ;
29362 0 : delete [] storageArray;
29363 0 : SgUpcMythreadStorageClass :: writeEasyStorageDataToFile(out) ;
29364 : }
29365 :
29366 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcNotifyStatement );
29367 3 : storageClassIndex = 0 ;
29368 3 : if ( 0 < sizeOfActualPool )
29369 : {
29370 0 : SgUpcNotifyStatementStorageClass* storageArray = new SgUpcNotifyStatementStorageClass[sizeOfActualPool] ;
29371 0 : storageClassIndex = SgUpcNotifyStatement::initializeStorageClassArray (storageArray); ;
29372 0 : assert ( storageClassIndex == sizeOfActualPool );
29373 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcNotifyStatementStorageClass ) * sizeOfActualPool) ;
29374 0 : delete [] storageArray;
29375 0 : SgUpcNotifyStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29376 : }
29377 :
29378 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcThreads );
29379 3 : storageClassIndex = 0 ;
29380 3 : if ( 0 < sizeOfActualPool )
29381 : {
29382 0 : SgUpcThreadsStorageClass* storageArray = new SgUpcThreadsStorageClass[sizeOfActualPool] ;
29383 0 : storageClassIndex = SgUpcThreads::initializeStorageClassArray (storageArray); ;
29384 0 : assert ( storageClassIndex == sizeOfActualPool );
29385 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcThreadsStorageClass ) * sizeOfActualPool) ;
29386 0 : delete [] storageArray;
29387 0 : SgUpcThreadsStorageClass :: writeEasyStorageDataToFile(out) ;
29388 : }
29389 :
29390 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUpcWaitStatement );
29391 3 : storageClassIndex = 0 ;
29392 3 : if ( 0 < sizeOfActualPool )
29393 : {
29394 0 : SgUpcWaitStatementStorageClass* storageArray = new SgUpcWaitStatementStorageClass[sizeOfActualPool] ;
29395 0 : storageClassIndex = SgUpcWaitStatement::initializeStorageClassArray (storageArray); ;
29396 0 : assert ( storageClassIndex == sizeOfActualPool );
29397 0 : out.write ( (char*) (storageArray) , sizeof ( SgUpcWaitStatementStorageClass ) * sizeOfActualPool) ;
29398 0 : delete [] storageArray;
29399 0 : SgUpcWaitStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29400 : }
29401 :
29402 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUseStatement );
29403 3 : storageClassIndex = 0 ;
29404 3 : if ( 0 < sizeOfActualPool )
29405 : {
29406 0 : SgUseStatementStorageClass* storageArray = new SgUseStatementStorageClass[sizeOfActualPool] ;
29407 0 : storageClassIndex = SgUseStatement::initializeStorageClassArray (storageArray); ;
29408 0 : assert ( storageClassIndex == sizeOfActualPool );
29409 0 : out.write ( (char*) (storageArray) , sizeof ( SgUseStatementStorageClass ) * sizeOfActualPool) ;
29410 0 : delete [] storageArray;
29411 0 : SgUseStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29412 : }
29413 :
29414 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUserDefinedBinaryOp );
29415 3 : storageClassIndex = 0 ;
29416 3 : if ( 0 < sizeOfActualPool )
29417 : {
29418 0 : SgUserDefinedBinaryOpStorageClass* storageArray = new SgUserDefinedBinaryOpStorageClass[sizeOfActualPool] ;
29419 0 : storageClassIndex = SgUserDefinedBinaryOp::initializeStorageClassArray (storageArray); ;
29420 0 : assert ( storageClassIndex == sizeOfActualPool );
29421 0 : out.write ( (char*) (storageArray) , sizeof ( SgUserDefinedBinaryOpStorageClass ) * sizeOfActualPool) ;
29422 0 : delete [] storageArray;
29423 0 : SgUserDefinedBinaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
29424 : }
29425 :
29426 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUserDefinedUnaryOp );
29427 3 : storageClassIndex = 0 ;
29428 3 : if ( 0 < sizeOfActualPool )
29429 : {
29430 0 : SgUserDefinedUnaryOpStorageClass* storageArray = new SgUserDefinedUnaryOpStorageClass[sizeOfActualPool] ;
29431 0 : storageClassIndex = SgUserDefinedUnaryOp::initializeStorageClassArray (storageArray); ;
29432 0 : assert ( storageClassIndex == sizeOfActualPool );
29433 0 : out.write ( (char*) (storageArray) , sizeof ( SgUserDefinedUnaryOpStorageClass ) * sizeOfActualPool) ;
29434 0 : delete [] storageArray;
29435 0 : SgUserDefinedUnaryOpStorageClass :: writeEasyStorageDataToFile(out) ;
29436 : }
29437 :
29438 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUsingDeclarationStatement );
29439 3 : storageClassIndex = 0 ;
29440 3 : if ( 0 < sizeOfActualPool )
29441 : {
29442 276 : SgUsingDeclarationStatementStorageClass* storageArray = new SgUsingDeclarationStatementStorageClass[sizeOfActualPool] ;
29443 1 : storageClassIndex = SgUsingDeclarationStatement::initializeStorageClassArray (storageArray); ;
29444 1 : assert ( storageClassIndex == sizeOfActualPool );
29445 1 : out.write ( (char*) (storageArray) , sizeof ( SgUsingDeclarationStatementStorageClass ) * sizeOfActualPool) ;
29446 1 : delete [] storageArray;
29447 1 : SgUsingDeclarationStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29448 : }
29449 :
29450 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgUsingDirectiveStatement );
29451 3 : storageClassIndex = 0 ;
29452 3 : if ( 0 < sizeOfActualPool )
29453 : {
29454 2 : SgUsingDirectiveStatementStorageClass* storageArray = new SgUsingDirectiveStatementStorageClass[sizeOfActualPool] ;
29455 1 : storageClassIndex = SgUsingDirectiveStatement::initializeStorageClassArray (storageArray); ;
29456 1 : assert ( storageClassIndex == sizeOfActualPool );
29457 1 : out.write ( (char*) (storageArray) , sizeof ( SgUsingDirectiveStatementStorageClass ) * sizeOfActualPool) ;
29458 1 : delete [] storageArray;
29459 1 : SgUsingDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29460 : }
29461 :
29462 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgValueExp );
29463 3 : storageClassIndex = 0 ;
29464 3 : if ( 0 < sizeOfActualPool )
29465 : {
29466 0 : SgValueExpStorageClass* storageArray = new SgValueExpStorageClass[sizeOfActualPool] ;
29467 0 : storageClassIndex = SgValueExp::initializeStorageClassArray (storageArray); ;
29468 0 : assert ( storageClassIndex == sizeOfActualPool );
29469 0 : out.write ( (char*) (storageArray) , sizeof ( SgValueExpStorageClass ) * sizeOfActualPool) ;
29470 0 : delete [] storageArray;
29471 0 : SgValueExpStorageClass :: writeEasyStorageDataToFile(out) ;
29472 : }
29473 :
29474 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarArgCopyOp );
29475 3 : storageClassIndex = 0 ;
29476 3 : if ( 0 < sizeOfActualPool )
29477 : {
29478 0 : SgVarArgCopyOpStorageClass* storageArray = new SgVarArgCopyOpStorageClass[sizeOfActualPool] ;
29479 0 : storageClassIndex = SgVarArgCopyOp::initializeStorageClassArray (storageArray); ;
29480 0 : assert ( storageClassIndex == sizeOfActualPool );
29481 0 : out.write ( (char*) (storageArray) , sizeof ( SgVarArgCopyOpStorageClass ) * sizeOfActualPool) ;
29482 0 : delete [] storageArray;
29483 0 : SgVarArgCopyOpStorageClass :: writeEasyStorageDataToFile(out) ;
29484 : }
29485 :
29486 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarArgEndOp );
29487 3 : storageClassIndex = 0 ;
29488 3 : if ( 0 < sizeOfActualPool )
29489 : {
29490 0 : SgVarArgEndOpStorageClass* storageArray = new SgVarArgEndOpStorageClass[sizeOfActualPool] ;
29491 0 : storageClassIndex = SgVarArgEndOp::initializeStorageClassArray (storageArray); ;
29492 0 : assert ( storageClassIndex == sizeOfActualPool );
29493 0 : out.write ( (char*) (storageArray) , sizeof ( SgVarArgEndOpStorageClass ) * sizeOfActualPool) ;
29494 0 : delete [] storageArray;
29495 0 : SgVarArgEndOpStorageClass :: writeEasyStorageDataToFile(out) ;
29496 : }
29497 :
29498 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarArgOp );
29499 3 : storageClassIndex = 0 ;
29500 3 : if ( 0 < sizeOfActualPool )
29501 : {
29502 0 : SgVarArgOpStorageClass* storageArray = new SgVarArgOpStorageClass[sizeOfActualPool] ;
29503 0 : storageClassIndex = SgVarArgOp::initializeStorageClassArray (storageArray); ;
29504 0 : assert ( storageClassIndex == sizeOfActualPool );
29505 0 : out.write ( (char*) (storageArray) , sizeof ( SgVarArgOpStorageClass ) * sizeOfActualPool) ;
29506 0 : delete [] storageArray;
29507 0 : SgVarArgOpStorageClass :: writeEasyStorageDataToFile(out) ;
29508 : }
29509 :
29510 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarArgStartOneOperandOp );
29511 3 : storageClassIndex = 0 ;
29512 3 : if ( 0 < sizeOfActualPool )
29513 : {
29514 0 : SgVarArgStartOneOperandOpStorageClass* storageArray = new SgVarArgStartOneOperandOpStorageClass[sizeOfActualPool] ;
29515 0 : storageClassIndex = SgVarArgStartOneOperandOp::initializeStorageClassArray (storageArray); ;
29516 0 : assert ( storageClassIndex == sizeOfActualPool );
29517 0 : out.write ( (char*) (storageArray) , sizeof ( SgVarArgStartOneOperandOpStorageClass ) * sizeOfActualPool) ;
29518 0 : delete [] storageArray;
29519 0 : SgVarArgStartOneOperandOpStorageClass :: writeEasyStorageDataToFile(out) ;
29520 : }
29521 :
29522 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarArgStartOp );
29523 3 : storageClassIndex = 0 ;
29524 3 : if ( 0 < sizeOfActualPool )
29525 : {
29526 0 : SgVarArgStartOpStorageClass* storageArray = new SgVarArgStartOpStorageClass[sizeOfActualPool] ;
29527 0 : storageClassIndex = SgVarArgStartOp::initializeStorageClassArray (storageArray); ;
29528 0 : assert ( storageClassIndex == sizeOfActualPool );
29529 0 : out.write ( (char*) (storageArray) , sizeof ( SgVarArgStartOpStorageClass ) * sizeOfActualPool) ;
29530 0 : delete [] storageArray;
29531 0 : SgVarArgStartOpStorageClass :: writeEasyStorageDataToFile(out) ;
29532 : }
29533 :
29534 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVarRefExp );
29535 3 : storageClassIndex = 0 ;
29536 3 : if ( 0 < sizeOfActualPool )
29537 : {
29538 6512 : SgVarRefExpStorageClass* storageArray = new SgVarRefExpStorageClass[sizeOfActualPool] ;
29539 1 : storageClassIndex = SgVarRefExp::initializeStorageClassArray (storageArray); ;
29540 1 : assert ( storageClassIndex == sizeOfActualPool );
29541 1 : out.write ( (char*) (storageArray) , sizeof ( SgVarRefExpStorageClass ) * sizeOfActualPool) ;
29542 1 : delete [] storageArray;
29543 1 : SgVarRefExpStorageClass :: writeEasyStorageDataToFile(out) ;
29544 : }
29545 :
29546 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVariableDeclaration );
29547 3 : storageClassIndex = 0 ;
29548 3 : if ( 0 < sizeOfActualPool )
29549 : {
29550 1296 : SgVariableDeclarationStorageClass* storageArray = new SgVariableDeclarationStorageClass[sizeOfActualPool] ;
29551 2 : storageClassIndex = SgVariableDeclaration::initializeStorageClassArray (storageArray); ;
29552 2 : assert ( storageClassIndex == sizeOfActualPool );
29553 2 : out.write ( (char*) (storageArray) , sizeof ( SgVariableDeclarationStorageClass ) * sizeOfActualPool) ;
29554 2 : delete [] storageArray;
29555 2 : SgVariableDeclarationStorageClass :: writeEasyStorageDataToFile(out) ;
29556 : }
29557 :
29558 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVariableDefinition );
29559 3 : storageClassIndex = 0 ;
29560 3 : if ( 0 < sizeOfActualPool )
29561 : {
29562 1398 : SgVariableDefinitionStorageClass* storageArray = new SgVariableDefinitionStorageClass[sizeOfActualPool] ;
29563 2 : storageClassIndex = SgVariableDefinition::initializeStorageClassArray (storageArray); ;
29564 2 : assert ( storageClassIndex == sizeOfActualPool );
29565 2 : out.write ( (char*) (storageArray) , sizeof ( SgVariableDefinitionStorageClass ) * sizeOfActualPool) ;
29566 2 : delete [] storageArray;
29567 2 : SgVariableDefinitionStorageClass :: writeEasyStorageDataToFile(out) ;
29568 : }
29569 :
29570 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVariableSymbol );
29571 3 : storageClassIndex = 0 ;
29572 3 : if ( 0 < sizeOfActualPool )
29573 : {
29574 4228 : SgVariableSymbolStorageClass* storageArray = new SgVariableSymbolStorageClass[sizeOfActualPool] ;
29575 2 : storageClassIndex = SgVariableSymbol::initializeStorageClassArray (storageArray); ;
29576 2 : assert ( storageClassIndex == sizeOfActualPool );
29577 2 : out.write ( (char*) (storageArray) , sizeof ( SgVariableSymbolStorageClass ) * sizeOfActualPool) ;
29578 2 : delete [] storageArray;
29579 2 : SgVariableSymbolStorageClass :: writeEasyStorageDataToFile(out) ;
29580 : }
29581 :
29582 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVariantExpression );
29583 3 : storageClassIndex = 0 ;
29584 3 : if ( 0 < sizeOfActualPool )
29585 : {
29586 0 : SgVariantExpressionStorageClass* storageArray = new SgVariantExpressionStorageClass[sizeOfActualPool] ;
29587 0 : storageClassIndex = SgVariantExpression::initializeStorageClassArray (storageArray); ;
29588 0 : assert ( storageClassIndex == sizeOfActualPool );
29589 0 : out.write ( (char*) (storageArray) , sizeof ( SgVariantExpressionStorageClass ) * sizeOfActualPool) ;
29590 0 : delete [] storageArray;
29591 0 : SgVariantExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29592 : }
29593 :
29594 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVariantStatement );
29595 3 : storageClassIndex = 0 ;
29596 3 : if ( 0 < sizeOfActualPool )
29597 : {
29598 0 : SgVariantStatementStorageClass* storageArray = new SgVariantStatementStorageClass[sizeOfActualPool] ;
29599 0 : storageClassIndex = SgVariantStatement::initializeStorageClassArray (storageArray); ;
29600 0 : assert ( storageClassIndex == sizeOfActualPool );
29601 0 : out.write ( (char*) (storageArray) , sizeof ( SgVariantStatementStorageClass ) * sizeOfActualPool) ;
29602 0 : delete [] storageArray;
29603 0 : SgVariantStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29604 : }
29605 :
29606 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgVoidVal );
29607 3 : storageClassIndex = 0 ;
29608 3 : if ( 0 < sizeOfActualPool )
29609 : {
29610 0 : SgVoidValStorageClass* storageArray = new SgVoidValStorageClass[sizeOfActualPool] ;
29611 0 : storageClassIndex = SgVoidVal::initializeStorageClassArray (storageArray); ;
29612 0 : assert ( storageClassIndex == sizeOfActualPool );
29613 0 : out.write ( (char*) (storageArray) , sizeof ( SgVoidValStorageClass ) * sizeOfActualPool) ;
29614 0 : delete [] storageArray;
29615 0 : SgVoidValStorageClass :: writeEasyStorageDataToFile(out) ;
29616 : }
29617 :
29618 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWaitStatement );
29619 3 : storageClassIndex = 0 ;
29620 3 : if ( 0 < sizeOfActualPool )
29621 : {
29622 0 : SgWaitStatementStorageClass* storageArray = new SgWaitStatementStorageClass[sizeOfActualPool] ;
29623 0 : storageClassIndex = SgWaitStatement::initializeStorageClassArray (storageArray); ;
29624 0 : assert ( storageClassIndex == sizeOfActualPool );
29625 0 : out.write ( (char*) (storageArray) , sizeof ( SgWaitStatementStorageClass ) * sizeOfActualPool) ;
29626 0 : delete [] storageArray;
29627 0 : SgWaitStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29628 : }
29629 :
29630 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWarningDirectiveStatement );
29631 3 : storageClassIndex = 0 ;
29632 3 : if ( 0 < sizeOfActualPool )
29633 : {
29634 0 : SgWarningDirectiveStatementStorageClass* storageArray = new SgWarningDirectiveStatementStorageClass[sizeOfActualPool] ;
29635 0 : storageClassIndex = SgWarningDirectiveStatement::initializeStorageClassArray (storageArray); ;
29636 0 : assert ( storageClassIndex == sizeOfActualPool );
29637 0 : out.write ( (char*) (storageArray) , sizeof ( SgWarningDirectiveStatementStorageClass ) * sizeOfActualPool) ;
29638 0 : delete [] storageArray;
29639 0 : SgWarningDirectiveStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29640 : }
29641 :
29642 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWithStatement );
29643 3 : storageClassIndex = 0 ;
29644 3 : if ( 0 < sizeOfActualPool )
29645 : {
29646 0 : SgWithStatementStorageClass* storageArray = new SgWithStatementStorageClass[sizeOfActualPool] ;
29647 0 : storageClassIndex = SgWithStatement::initializeStorageClassArray (storageArray); ;
29648 0 : assert ( storageClassIndex == sizeOfActualPool );
29649 0 : out.write ( (char*) (storageArray) , sizeof ( SgWithStatementStorageClass ) * sizeOfActualPool) ;
29650 0 : delete [] storageArray;
29651 0 : SgWithStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29652 : }
29653 :
29654 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWcharVal );
29655 3 : storageClassIndex = 0 ;
29656 3 : if ( 0 < sizeOfActualPool )
29657 : {
29658 0 : SgWcharValStorageClass* storageArray = new SgWcharValStorageClass[sizeOfActualPool] ;
29659 0 : storageClassIndex = SgWcharVal::initializeStorageClassArray (storageArray); ;
29660 0 : assert ( storageClassIndex == sizeOfActualPool );
29661 0 : out.write ( (char*) (storageArray) , sizeof ( SgWcharValStorageClass ) * sizeOfActualPool) ;
29662 0 : delete [] storageArray;
29663 0 : SgWcharValStorageClass :: writeEasyStorageDataToFile(out) ;
29664 : }
29665 :
29666 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWhereStatement );
29667 3 : storageClassIndex = 0 ;
29668 3 : if ( 0 < sizeOfActualPool )
29669 : {
29670 0 : SgWhereStatementStorageClass* storageArray = new SgWhereStatementStorageClass[sizeOfActualPool] ;
29671 0 : storageClassIndex = SgWhereStatement::initializeStorageClassArray (storageArray); ;
29672 0 : assert ( storageClassIndex == sizeOfActualPool );
29673 0 : out.write ( (char*) (storageArray) , sizeof ( SgWhereStatementStorageClass ) * sizeOfActualPool) ;
29674 0 : delete [] storageArray;
29675 0 : SgWhereStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29676 : }
29677 :
29678 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWhileStmt );
29679 3 : storageClassIndex = 0 ;
29680 3 : if ( 0 < sizeOfActualPool )
29681 : {
29682 48 : SgWhileStmtStorageClass* storageArray = new SgWhileStmtStorageClass[sizeOfActualPool] ;
29683 1 : storageClassIndex = SgWhileStmt::initializeStorageClassArray (storageArray); ;
29684 1 : assert ( storageClassIndex == sizeOfActualPool );
29685 1 : out.write ( (char*) (storageArray) , sizeof ( SgWhileStmtStorageClass ) * sizeOfActualPool) ;
29686 1 : delete [] storageArray;
29687 1 : SgWhileStmtStorageClass :: writeEasyStorageDataToFile(out) ;
29688 : }
29689 :
29690 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgWriteStatement );
29691 3 : storageClassIndex = 0 ;
29692 3 : if ( 0 < sizeOfActualPool )
29693 : {
29694 0 : SgWriteStatementStorageClass* storageArray = new SgWriteStatementStorageClass[sizeOfActualPool] ;
29695 0 : storageClassIndex = SgWriteStatement::initializeStorageClassArray (storageArray); ;
29696 0 : assert ( storageClassIndex == sizeOfActualPool );
29697 0 : out.write ( (char*) (storageArray) , sizeof ( SgWriteStatementStorageClass ) * sizeOfActualPool) ;
29698 0 : delete [] storageArray;
29699 0 : SgWriteStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29700 : }
29701 :
29702 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgXorAssignOp );
29703 3 : storageClassIndex = 0 ;
29704 3 : if ( 0 < sizeOfActualPool )
29705 : {
29706 0 : SgXorAssignOpStorageClass* storageArray = new SgXorAssignOpStorageClass[sizeOfActualPool] ;
29707 0 : storageClassIndex = SgXorAssignOp::initializeStorageClassArray (storageArray); ;
29708 0 : assert ( storageClassIndex == sizeOfActualPool );
29709 0 : out.write ( (char*) (storageArray) , sizeof ( SgXorAssignOpStorageClass ) * sizeOfActualPool) ;
29710 0 : delete [] storageArray;
29711 0 : SgXorAssignOpStorageClass :: writeEasyStorageDataToFile(out) ;
29712 : }
29713 :
29714 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgYieldExpression );
29715 3 : storageClassIndex = 0 ;
29716 3 : if ( 0 < sizeOfActualPool )
29717 : {
29718 0 : SgYieldExpressionStorageClass* storageArray = new SgYieldExpressionStorageClass[sizeOfActualPool] ;
29719 0 : storageClassIndex = SgYieldExpression::initializeStorageClassArray (storageArray); ;
29720 0 : assert ( storageClassIndex == sizeOfActualPool );
29721 0 : out.write ( (char*) (storageArray) , sizeof ( SgYieldExpressionStorageClass ) * sizeOfActualPool) ;
29722 0 : delete [] storageArray;
29723 0 : SgYieldExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29724 : }
29725 :
29726 3 : sizeOfActualPool = getSizeOfMemoryPool(V_Sg_File_Info );
29727 3 : storageClassIndex = 0 ;
29728 3 : if ( 0 < sizeOfActualPool )
29729 : {
29730 648016 : Sg_File_InfoStorageClass* storageArray = new Sg_File_InfoStorageClass[sizeOfActualPool] ;
29731 3 : storageClassIndex = Sg_File_Info::initializeStorageClassArray (storageArray); ;
29732 3 : assert ( storageClassIndex == sizeOfActualPool );
29733 3 : out.write ( (char*) (storageArray) , sizeof ( Sg_File_InfoStorageClass ) * sizeOfActualPool) ;
29734 3 : delete [] storageArray;
29735 3 : Sg_File_InfoStorageClass :: writeEasyStorageDataToFile(out) ;
29736 : }
29737 :
29738 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeCAFTeam );
29739 3 : storageClassIndex = 0 ;
29740 3 : if ( 0 < sizeOfActualPool )
29741 : {
29742 0 : SgTypeCAFTeamStorageClass* storageArray = new SgTypeCAFTeamStorageClass[sizeOfActualPool] ;
29743 0 : storageClassIndex = SgTypeCAFTeam::initializeStorageClassArray (storageArray); ;
29744 0 : assert ( storageClassIndex == sizeOfActualPool );
29745 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeCAFTeamStorageClass ) * sizeOfActualPool) ;
29746 0 : delete [] storageArray;
29747 0 : SgTypeCAFTeamStorageClass :: writeEasyStorageDataToFile(out) ;
29748 : }
29749 :
29750 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCAFWithTeamStatement );
29751 3 : storageClassIndex = 0 ;
29752 3 : if ( 0 < sizeOfActualPool )
29753 : {
29754 0 : SgCAFWithTeamStatementStorageClass* storageArray = new SgCAFWithTeamStatementStorageClass[sizeOfActualPool] ;
29755 0 : storageClassIndex = SgCAFWithTeamStatement::initializeStorageClassArray (storageArray); ;
29756 0 : assert ( storageClassIndex == sizeOfActualPool );
29757 0 : out.write ( (char*) (storageArray) , sizeof ( SgCAFWithTeamStatementStorageClass ) * sizeOfActualPool) ;
29758 0 : delete [] storageArray;
29759 0 : SgCAFWithTeamStatementStorageClass :: writeEasyStorageDataToFile(out) ;
29760 : }
29761 :
29762 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCAFCoExpression );
29763 3 : storageClassIndex = 0 ;
29764 3 : if ( 0 < sizeOfActualPool )
29765 : {
29766 0 : SgCAFCoExpressionStorageClass* storageArray = new SgCAFCoExpressionStorageClass[sizeOfActualPool] ;
29767 0 : storageClassIndex = SgCAFCoExpression::initializeStorageClassArray (storageArray); ;
29768 0 : assert ( storageClassIndex == sizeOfActualPool );
29769 0 : out.write ( (char*) (storageArray) , sizeof ( SgCAFCoExpressionStorageClass ) * sizeOfActualPool) ;
29770 0 : delete [] storageArray;
29771 0 : SgCAFCoExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29772 : }
29773 :
29774 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgCallExpression );
29775 3 : storageClassIndex = 0 ;
29776 3 : if ( 0 < sizeOfActualPool )
29777 : {
29778 0 : SgCallExpressionStorageClass* storageArray = new SgCallExpressionStorageClass[sizeOfActualPool] ;
29779 0 : storageClassIndex = SgCallExpression::initializeStorageClassArray (storageArray); ;
29780 0 : assert ( storageClassIndex == sizeOfActualPool );
29781 0 : out.write ( (char*) (storageArray) , sizeof ( SgCallExpressionStorageClass ) * sizeOfActualPool) ;
29782 0 : delete [] storageArray;
29783 0 : SgCallExpressionStorageClass :: writeEasyStorageDataToFile(out) ;
29784 : }
29785 :
29786 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgTypeCrayPointer );
29787 3 : storageClassIndex = 0 ;
29788 3 : if ( 0 < sizeOfActualPool )
29789 : {
29790 0 : SgTypeCrayPointerStorageClass* storageArray = new SgTypeCrayPointerStorageClass[sizeOfActualPool] ;
29791 0 : storageClassIndex = SgTypeCrayPointer::initializeStorageClassArray (storageArray); ;
29792 0 : assert ( storageClassIndex == sizeOfActualPool );
29793 0 : out.write ( (char*) (storageArray) , sizeof ( SgTypeCrayPointerStorageClass ) * sizeOfActualPool) ;
29794 0 : delete [] storageArray;
29795 0 : SgTypeCrayPointerStorageClass :: writeEasyStorageDataToFile(out) ;
29796 : }
29797 :
29798 3 : sizeOfActualPool = getSizeOfMemoryPool(V_SgClassExp );
29799 3 : storageClassIndex = 0 ;
29800 3 : if ( 0 < sizeOfActualPool )
29801 : {
29802 0 : SgClassExpStorageClass* storageArray = new SgClassExpStorageClass[sizeOfActualPool] ;
29803 0 : storageClassIndex = SgClassExp::initializeStorageClassArray (storageArray); ;
29804 0 : assert ( storageClassIndex == sizeOfActualPool );
29805 0 : out.write ( (char*) (storageArray) , sizeof ( SgClassExpStorageClass ) * sizeOfActualPool) ;
29806 0 : delete [] storageArray;
29807 0 : SgClassExpStorageClass :: writeEasyStorageDataToFile(out) ;
29808 : }
29809 :
29810 :
29811 : /* #line 549 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
29812 :
29813 : }
29814 :
29815 3 : {
29816 : // DQ (4/22/2006): Added timer information for AST File I/O
29817 3 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile() closing file:");
29818 6 : std::string endString = "ROSE_AST_BINARY_END";
29819 3 : out.write ( endString.c_str(), endString.size() );
29820 : }
29821 :
29822 : // clear everything, actually, this does not work, since I need a different way to
29823 : // initialize the actualRebuildAst
29824 : // delete actualRebuildAst;
29825 : // vectorOfASTs.clear();
29826 :
29827 :
29828 6 : return ;
29829 : }
29830 :
29831 :
29832 : /* JH (01/03/2006) This method stores an AST in binary format to the file.
29833 : */
29834 : void
29835 3 : AST_FILE_IO :: writeASTToFile ( std::string fileName )
29836 : {
29837 : // DQ (4/22/2006): Added timer information for AST File I/O
29838 6 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile():");
29839 :
29840 3 : std::ofstream out;
29841 3 : out.open ( fileName.c_str(), std::ios::out | std::ios::binary );
29842 3 : if ( !out )
29843 : {
29844 0 : std::cout << "Problems opening file " << fileName << " for writing AST!" << std::endl;
29845 0 : exit(-1);
29846 : }
29847 3 : AST_FILE_IO::writeASTToStream(out);
29848 :
29849 3 : {
29850 : // DQ (4/22/2006): Added timer information for AST File I/O
29851 6 : TimingPerformance timer ("AST_FILE_IO::writeASTToFile() closing file: time (sec) = ");
29852 3 : out.close() ;
29853 : }
29854 :
29855 6 : return ;
29856 : }
29857 :
29858 : std::string
29859 0 : AST_FILE_IO :: writeASTToString()
29860 : {
29861 0 : std::ostringstream out;
29862 0 : AST_FILE_IO::writeASTToStream(out);
29863 0 : return out.str();
29864 : }
29865 :
29866 : /* JW (06/21/2006) Changed to use streams in base implementation */
29867 : SgProject*
29868 2 : AST_FILE_IO :: readASTFromStream ( std::istream& inFile )
29869 : {
29870 : // DQ (4/22/2006): Added timer information for AST File I/O
29871 2 : TimingPerformance timer ("AST_FILE_IO::readASTFromStream() time (sec) = ");
29872 :
29873 2 : assert ( freepointersOfCurrentAstAreSetToGlobalIndices == false );
29874 4 : std::string startString = "ROSE_AST_BINARY_START";
29875 2 : char* startChar = new char [startString.size()+1];
29876 2 : startChar[startString.size()] = '\0';
29877 2 : inFile.read ( startChar, startString.size() );
29878 2 : assert (inFile);
29879 2 : assert ( string(startChar) == startString );
29880 2 : delete [] startChar;
29881 2 : REGISTER_ATTRIBUTE_FOR_FILE_IO(AstAttribute) ;
29882 :
29883 : // 1. Read the accumulatedPoolSizesOfNewAst
29884 2 : if ( SgProject::get_verbose() > 0 )
29885 0 : std::cout << "Here we start the reading of the AST specific data ... " << std::endl;
29886 :
29887 2 : if ( SgProject::get_verbose() > 0 )
29888 0 : std::cout << " Allocating AstDataStorageClass ... " << std::endl;
29889 2 : AstDataStorageClass staticTemp;
29890 :
29891 2 : if ( SgProject::get_verbose() > 0 )
29892 0 : std::cout << " Checking the ast via pool entries -- before AstDataStorageClass::readEasyStorageDataFromFile() .... " << std::endl;
29893 :
29894 : #if FILE_IO_MEMORY_POOL_CHECK
29895 : // AST_FileIO::MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_A;
29896 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_A;
29897 : memoryCheckingTraversal_A.traverseMemoryPool();
29898 : #endif
29899 :
29900 2 : if ( SgProject::get_verbose() > 0 )
29901 0 : std::cout << " DONE: Checking the ast via pool entries -- before AstDataStorageClass::readEasyStorageDataFromFile() .... " << std::endl;
29902 :
29903 2 : {
29904 : // DQ (4/22/2006): Added timer information for AST File I/O
29905 4 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() raw file read:");
29906 :
29907 2 : if ( SgProject::get_verbose() > 0 )
29908 0 : std::cout << " Reading the data from file ... " << std::endl;
29909 :
29910 2 : inFile.read ( (char*)(&staticTemp) , sizeof(AstDataStorageClass) );
29911 2 : assert (inFile);
29912 :
29913 2 : if ( SgProject::get_verbose() > 0 )
29914 0 : std::cout << " Reading the static (EasyStorage) data from file ... " << std::endl;
29915 :
29916 2 : AstDataStorageClass::readEasyStorageDataFromFile(inFile);
29917 : }
29918 :
29919 2 : if ( SgProject::get_verbose() > 0 )
29920 0 : std::cout << " Checking the ast via pool entries -- after AstDataStorageClass::readEasyStorageDataFromFile() .... " << std::endl;
29921 :
29922 : #if FILE_IO_MEMORY_POOL_CHECK
29923 : // AST_FileIO::MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_B;
29924 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_B;
29925 : memoryCheckingTraversal_B.traverseMemoryPool();
29926 : #endif
29927 :
29928 2 : if ( SgProject::get_verbose() > 0 )
29929 0 : std::cout << " DONE: Checking the ast via pool entries -- after AstDataStorageClass::readEasyStorageDataFromFile() .... " << std::endl;
29930 :
29931 : // 1.a Introducing a marker to check the right position in the file
29932 :
29933 2 : {
29934 : // DQ (4/22/2006): Added timer information for AST File I/O
29935 2 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() raw file (marker) read:");
29936 :
29937 4 : std::string markString = "#########";
29938 2 : char* markChar = new char [markString.size()+1];
29939 :
29940 : // DQ (9/24/2007): Bug fix suggested by Jeremiah.
29941 2 : markChar[markString.size()] = '\0';
29942 :
29943 2 : inFile.read ( markChar, markString.size() );
29944 2 : assert (inFile);
29945 2 : assert ( string(markChar) == markString );
29946 2 : delete [] markChar;
29947 : }
29948 :
29949 2 : if ( SgProject::get_verbose() > 0 )
29950 0 : std::cout << " Checking the ast via pool entries -- after marker read .... " << std::endl;
29951 :
29952 : #if FILE_IO_MEMORY_POOL_CHECK
29953 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_C;
29954 : memoryCheckingTraversal_C.traverseMemoryPool();
29955 : #endif
29956 :
29957 2 : if ( SgProject::get_verbose() > 0 )
29958 0 : std::cout << " DONE: Checking the ast via pool entries -- after marker read .... " << std::endl;
29959 :
29960 : // 2. Initialize the StorageClass and read
29961 :
29962 2 : {
29963 : // DQ (4/22/2006): Added timer information for AST File I/O
29964 4 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() rebuild AST (part 1):");
29965 :
29966 2 : if ( SgProject::get_verbose() > 0 )
29967 0 : std::cout << " Initializing the actualRebuildAST with staticTemp ... " << std::endl;
29968 :
29969 : // This calls the constructor AstSpecificDataManagingClass(const AstSpecificDataManagingClassStorageClass& source ).
29970 : // The code used to generate this function is in: ROSETTA/src/buildStorageClasses.C
29971 : // Note that AstData is typedefed to AstSpecificDataManagingClass
29972 2 : actualRebuildAst = new AstData(staticTemp);
29973 : // extendMemoryPoolsForRebuildingAST();
29974 :
29975 : // The call to the constructor calls "extendMemoryPoolsForRebuildingAST()" which uses valid pointers
29976 : // to reference the extended memory blocks where the new AST extends beyond the current memory block.
29977 : // This means that freepointer values at the end of a sequence of memroy blocks will have values
29978 : // that are not equal to "AST_FileIO::IS_VALID_POINTER()", thus causing warnings to be spewed
29979 : // from the "MemoryCheckingTraversalForAstFileIO" tests (which I have added more of lately).
29980 : // It seems that calling "new AstData(staticTemp)" is not meant to be done where part of the AST was
29981 : // read from a file??? Also the frepointer value of the next to last block in the memory block list
29982 : // appears to be lost after the call to "extendMemoryPoolsForRebuildingAST()".
29983 :
29984 : // The problem is that when freepointers are converted to "AST_FileIO::IS_VALID_POINTER()", the last
29985 : // block in the chain is lost. since it points to an entry that is not allocated and thus not used.
29986 : // The freepointers, and/or the extension of the memory pools overwrites the last block in the chain.
29987 : // But I don't yet see exactly why!!!
29988 :
29989 : // One thing to test is if the new operators are working properly (or used) when the "AST_FileIO::IS_VALID_POINTER()"
29990 : // values are in place in the AST. Seems like it would be an error. to mix an AST read from disk with
29991 : // and AST that has been extended via "extendMemoryPoolsForRebuildingAST()".
29992 :
29993 : // I think the problem is in the conversion of freepointer values back to correct values after having
29994 : // been set as "AST_FileIO::IS_VALID_POINTER()" (particularly when the "AST_FileIO::IS_VALID_POINTER()"
29995 : // value has been over written.
29996 :
29997 2 : if ( SgProject::get_verbose() > 0 )
29998 0 : std::cout << " Checking the ast via pool entries -- after actualRebuildAst = new AstData() .... " << std::endl;
29999 :
30000 : #if FILE_IO_MEMORY_POOL_CHECK
30001 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_D;
30002 : memoryCheckingTraversal_D.traverseMemoryPool();
30003 : #endif
30004 :
30005 2 : if ( SgProject::get_verbose() > 0 )
30006 0 : std::cout << " DONE: Checking the ast via pool entries -- after actualRebuildAst = new AstData() .... " << std::endl;
30007 :
30008 : // 3.
30009 : // DQ (6/7/2010): Not clear why this is only called for where there is a single AST.
30010 : // printf ("AST_FILE_IO::vectorOfASTs.size() = %" PRIuPTR " \n",AST_FILE_IO::vectorOfASTs.size());
30011 2 : if (AST_FILE_IO::vectorOfASTs.size() == 1)
30012 : {
30013 0 : if ( SgProject::get_verbose() > 0 )
30014 0 : std::cout << "setting the static data of an AST, but only for the first AST in a pool ... " << std::flush;
30015 :
30016 0 : actualRebuildAst->setStaticDataMembersOfIRNodes();
30017 :
30018 0 : if ( SgProject::get_verbose() > 0 )
30019 0 : std::cout << "done" << std::endl;
30020 : }
30021 :
30022 2 : if ( SgProject::get_verbose() > 0 )
30023 0 : std::cout << " Calling AstDataStorageClass::deleteStaticDataOfEasyStorageClasses() .... " << std::endl;
30024 :
30025 : #if FILE_IO_MEMORY_POOL_CHECK
30026 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_D2;
30027 : memoryCheckingTraversal_D2.traverseMemoryPool();
30028 : #endif
30029 :
30030 2 : AstDataStorageClass::deleteStaticDataOfEasyStorageClasses();
30031 : }
30032 :
30033 2 : if ( SgProject::get_verbose() > 0 )
30034 0 : std::cout << " Checking the ast via pool entries -- after AstDataStorageClass::deleteStaticDataOfEasyStorageClasses() .... " << std::endl;
30035 :
30036 : #if FILE_IO_MEMORY_POOL_CHECK
30037 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal_E;
30038 : memoryCheckingTraversal_E.traverseMemoryPool();
30039 : #endif
30040 :
30041 2 : if ( SgProject::get_verbose() > 0 )
30042 0 : std::cout << " DONE: Checking the ast via pool entries -- after AstDataStorageClass::deleteStaticDataOfEasyStorageClasses() .... " << std::endl;
30043 :
30044 2 : {
30045 : // DQ (4/22/2006): Added timer information for AST File I/O
30046 4 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() rebuild AST (part 2):");
30047 :
30048 2 : unsigned long sizeOfActualPool = 0;
30049 : // DQ (9/3/2015): Fixed unsigned-ness of type.
30050 : // unsigned long storageClassIndex = 0 ;
30051 :
30052 :
30053 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAccessModifier );
30054 2 : SgAccessModifierStorageClass* storageArraySgAccessModifier = NULL;
30055 2 : if ( 0 < sizeOfActualPool )
30056 : {
30057 0 : storageArraySgAccessModifier = new SgAccessModifierStorageClass[sizeOfActualPool] ;
30058 0 : inFile.read ( (char*) (storageArraySgAccessModifier) , sizeof ( SgAccessModifierStorageClass ) * sizeOfActualPool) ;
30059 : SgAccessModifierStorageClass* storageArray = storageArraySgAccessModifier;
30060 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30061 : {
30062 0 : SgAccessModifier* tmp = new SgAccessModifier ( *storageArray ) ;
30063 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30064 0 : storageArray++ ;
30065 : }
30066 : }
30067 0 : delete [] storageArraySgAccessModifier;
30068 :
30069 :
30070 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgActualArgumentExpression );
30071 2 : SgActualArgumentExpressionStorageClass* storageArraySgActualArgumentExpression = NULL;
30072 2 : if ( 0 < sizeOfActualPool )
30073 : {
30074 0 : storageArraySgActualArgumentExpression = new SgActualArgumentExpressionStorageClass[sizeOfActualPool] ;
30075 0 : inFile.read ( (char*) (storageArraySgActualArgumentExpression) , sizeof ( SgActualArgumentExpressionStorageClass ) * sizeOfActualPool) ;
30076 0 : SgActualArgumentExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
30077 : SgActualArgumentExpressionStorageClass* storageArray = storageArraySgActualArgumentExpression;
30078 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30079 : {
30080 0 : SgActualArgumentExpression* tmp = new SgActualArgumentExpression ( *storageArray ) ;
30081 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30082 0 : storageArray++ ;
30083 : }
30084 : }
30085 0 : delete [] storageArraySgActualArgumentExpression;
30086 2 : SgActualArgumentExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
30087 :
30088 :
30089 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAddOp );
30090 2 : SgAddOpStorageClass* storageArraySgAddOp = NULL;
30091 2 : if ( 0 < sizeOfActualPool )
30092 : {
30093 191 : storageArraySgAddOp = new SgAddOpStorageClass[sizeOfActualPool] ;
30094 1 : inFile.read ( (char*) (storageArraySgAddOp) , sizeof ( SgAddOpStorageClass ) * sizeOfActualPool) ;
30095 1 : SgAddOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30096 : SgAddOpStorageClass* storageArray = storageArraySgAddOp;
30097 191 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30098 : {
30099 190 : SgAddOp* tmp = new SgAddOp ( *storageArray ) ;
30100 190 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30101 190 : storageArray++ ;
30102 : }
30103 : }
30104 1 : delete [] storageArraySgAddOp;
30105 2 : SgAddOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30106 :
30107 :
30108 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAddressOfOp );
30109 2 : SgAddressOfOpStorageClass* storageArraySgAddressOfOp = NULL;
30110 2 : if ( 0 < sizeOfActualPool )
30111 : {
30112 85 : storageArraySgAddressOfOp = new SgAddressOfOpStorageClass[sizeOfActualPool] ;
30113 1 : inFile.read ( (char*) (storageArraySgAddressOfOp) , sizeof ( SgAddressOfOpStorageClass ) * sizeOfActualPool) ;
30114 1 : SgAddressOfOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30115 : SgAddressOfOpStorageClass* storageArray = storageArraySgAddressOfOp;
30116 85 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30117 : {
30118 84 : SgAddressOfOp* tmp = new SgAddressOfOp ( *storageArray ) ;
30119 84 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30120 84 : storageArray++ ;
30121 : }
30122 : }
30123 1 : delete [] storageArraySgAddressOfOp;
30124 2 : SgAddressOfOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30125 :
30126 :
30127 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAggregateInitializer );
30128 2 : SgAggregateInitializerStorageClass* storageArraySgAggregateInitializer = NULL;
30129 2 : if ( 0 < sizeOfActualPool )
30130 : {
30131 4 : storageArraySgAggregateInitializer = new SgAggregateInitializerStorageClass[sizeOfActualPool] ;
30132 1 : inFile.read ( (char*) (storageArraySgAggregateInitializer) , sizeof ( SgAggregateInitializerStorageClass ) * sizeOfActualPool) ;
30133 1 : SgAggregateInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
30134 : SgAggregateInitializerStorageClass* storageArray = storageArraySgAggregateInitializer;
30135 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30136 : {
30137 3 : SgAggregateInitializer* tmp = new SgAggregateInitializer ( *storageArray ) ;
30138 3 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30139 3 : storageArray++ ;
30140 : }
30141 : }
30142 1 : delete [] storageArraySgAggregateInitializer;
30143 2 : SgAggregateInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
30144 :
30145 :
30146 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAliasSymbol );
30147 2 : SgAliasSymbolStorageClass* storageArraySgAliasSymbol = NULL;
30148 2 : if ( 0 < sizeOfActualPool )
30149 : {
30150 13986 : storageArraySgAliasSymbol = new SgAliasSymbolStorageClass[sizeOfActualPool] ;
30151 2 : inFile.read ( (char*) (storageArraySgAliasSymbol) , sizeof ( SgAliasSymbolStorageClass ) * sizeOfActualPool) ;
30152 2 : SgAliasSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
30153 : SgAliasSymbolStorageClass* storageArray = storageArraySgAliasSymbol;
30154 13986 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30155 : {
30156 13984 : SgAliasSymbol* tmp = new SgAliasSymbol ( *storageArray ) ;
30157 13984 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30158 13984 : storageArray++ ;
30159 : }
30160 : }
30161 2 : delete [] storageArraySgAliasSymbol;
30162 2 : SgAliasSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
30163 :
30164 :
30165 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAllocateStatement );
30166 2 : SgAllocateStatementStorageClass* storageArraySgAllocateStatement = NULL;
30167 2 : if ( 0 < sizeOfActualPool )
30168 : {
30169 0 : storageArraySgAllocateStatement = new SgAllocateStatementStorageClass[sizeOfActualPool] ;
30170 0 : inFile.read ( (char*) (storageArraySgAllocateStatement) , sizeof ( SgAllocateStatementStorageClass ) * sizeOfActualPool) ;
30171 0 : SgAllocateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30172 : SgAllocateStatementStorageClass* storageArray = storageArraySgAllocateStatement;
30173 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30174 : {
30175 0 : SgAllocateStatement* tmp = new SgAllocateStatement ( *storageArray ) ;
30176 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30177 0 : storageArray++ ;
30178 : }
30179 : }
30180 0 : delete [] storageArraySgAllocateStatement;
30181 2 : SgAllocateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30182 :
30183 :
30184 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAndAssignOp );
30185 2 : SgAndAssignOpStorageClass* storageArraySgAndAssignOp = NULL;
30186 2 : if ( 0 < sizeOfActualPool )
30187 : {
30188 0 : storageArraySgAndAssignOp = new SgAndAssignOpStorageClass[sizeOfActualPool] ;
30189 0 : inFile.read ( (char*) (storageArraySgAndAssignOp) , sizeof ( SgAndAssignOpStorageClass ) * sizeOfActualPool) ;
30190 0 : SgAndAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30191 : SgAndAssignOpStorageClass* storageArray = storageArraySgAndAssignOp;
30192 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30193 : {
30194 0 : SgAndAssignOp* tmp = new SgAndAssignOp ( *storageArray ) ;
30195 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30196 0 : storageArray++ ;
30197 : }
30198 : }
30199 0 : delete [] storageArraySgAndAssignOp;
30200 2 : SgAndAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30201 :
30202 :
30203 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAndOp );
30204 2 : SgAndOpStorageClass* storageArraySgAndOp = NULL;
30205 2 : if ( 0 < sizeOfActualPool )
30206 : {
30207 174 : storageArraySgAndOp = new SgAndOpStorageClass[sizeOfActualPool] ;
30208 1 : inFile.read ( (char*) (storageArraySgAndOp) , sizeof ( SgAndOpStorageClass ) * sizeOfActualPool) ;
30209 1 : SgAndOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30210 : SgAndOpStorageClass* storageArray = storageArraySgAndOp;
30211 174 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30212 : {
30213 173 : SgAndOp* tmp = new SgAndOp ( *storageArray ) ;
30214 173 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30215 173 : storageArray++ ;
30216 : }
30217 : }
30218 1 : delete [] storageArraySgAndOp;
30219 2 : SgAndOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30220 :
30221 :
30222 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgArithmeticIfStatement );
30223 2 : SgArithmeticIfStatementStorageClass* storageArraySgArithmeticIfStatement = NULL;
30224 2 : if ( 0 < sizeOfActualPool )
30225 : {
30226 0 : storageArraySgArithmeticIfStatement = new SgArithmeticIfStatementStorageClass[sizeOfActualPool] ;
30227 0 : inFile.read ( (char*) (storageArraySgArithmeticIfStatement) , sizeof ( SgArithmeticIfStatementStorageClass ) * sizeOfActualPool) ;
30228 0 : SgArithmeticIfStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30229 : SgArithmeticIfStatementStorageClass* storageArray = storageArraySgArithmeticIfStatement;
30230 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30231 : {
30232 0 : SgArithmeticIfStatement* tmp = new SgArithmeticIfStatement ( *storageArray ) ;
30233 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30234 0 : storageArray++ ;
30235 : }
30236 : }
30237 0 : delete [] storageArraySgArithmeticIfStatement;
30238 2 : SgArithmeticIfStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30239 :
30240 :
30241 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgArrayType );
30242 2 : SgArrayTypeStorageClass* storageArraySgArrayType = NULL;
30243 2 : if ( 0 < sizeOfActualPool )
30244 : {
30245 110 : storageArraySgArrayType = new SgArrayTypeStorageClass[sizeOfActualPool] ;
30246 2 : inFile.read ( (char*) (storageArraySgArrayType) , sizeof ( SgArrayTypeStorageClass ) * sizeOfActualPool) ;
30247 2 : SgArrayTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
30248 : SgArrayTypeStorageClass* storageArray = storageArraySgArrayType;
30249 110 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30250 : {
30251 108 : SgArrayType* tmp = new SgArrayType ( *storageArray ) ;
30252 108 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30253 108 : storageArray++ ;
30254 : }
30255 : }
30256 2 : delete [] storageArraySgArrayType;
30257 2 : SgArrayTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
30258 :
30259 :
30260 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgArrowExp );
30261 2 : SgArrowExpStorageClass* storageArraySgArrowExp = NULL;
30262 2 : if ( 0 < sizeOfActualPool )
30263 : {
30264 1255 : storageArraySgArrowExp = new SgArrowExpStorageClass[sizeOfActualPool] ;
30265 1 : inFile.read ( (char*) (storageArraySgArrowExp) , sizeof ( SgArrowExpStorageClass ) * sizeOfActualPool) ;
30266 1 : SgArrowExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30267 : SgArrowExpStorageClass* storageArray = storageArraySgArrowExp;
30268 1255 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30269 : {
30270 1254 : SgArrowExp* tmp = new SgArrowExp ( *storageArray ) ;
30271 1254 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30272 1254 : storageArray++ ;
30273 : }
30274 : }
30275 1 : delete [] storageArraySgArrowExp;
30276 2 : SgArrowExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30277 :
30278 :
30279 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgArrowStarOp );
30280 2 : SgArrowStarOpStorageClass* storageArraySgArrowStarOp = NULL;
30281 2 : if ( 0 < sizeOfActualPool )
30282 : {
30283 5 : storageArraySgArrowStarOp = new SgArrowStarOpStorageClass[sizeOfActualPool] ;
30284 1 : inFile.read ( (char*) (storageArraySgArrowStarOp) , sizeof ( SgArrowStarOpStorageClass ) * sizeOfActualPool) ;
30285 1 : SgArrowStarOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30286 : SgArrowStarOpStorageClass* storageArray = storageArraySgArrowStarOp;
30287 5 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30288 : {
30289 4 : SgArrowStarOp* tmp = new SgArrowStarOp ( *storageArray ) ;
30290 4 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30291 4 : storageArray++ ;
30292 : }
30293 : }
30294 1 : delete [] storageArraySgArrowStarOp;
30295 2 : SgArrowStarOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30296 :
30297 :
30298 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAsmOp );
30299 2 : SgAsmOpStorageClass* storageArraySgAsmOp = NULL;
30300 2 : if ( 0 < sizeOfActualPool )
30301 : {
30302 0 : storageArraySgAsmOp = new SgAsmOpStorageClass[sizeOfActualPool] ;
30303 0 : inFile.read ( (char*) (storageArraySgAsmOp) , sizeof ( SgAsmOpStorageClass ) * sizeOfActualPool) ;
30304 0 : SgAsmOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30305 : SgAsmOpStorageClass* storageArray = storageArraySgAsmOp;
30306 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30307 : {
30308 0 : SgAsmOp* tmp = new SgAsmOp ( *storageArray ) ;
30309 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30310 0 : storageArray++ ;
30311 : }
30312 : }
30313 0 : delete [] storageArraySgAsmOp;
30314 2 : SgAsmOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30315 :
30316 :
30317 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAsmStmt );
30318 2 : SgAsmStmtStorageClass* storageArraySgAsmStmt = NULL;
30319 2 : if ( 0 < sizeOfActualPool )
30320 : {
30321 0 : storageArraySgAsmStmt = new SgAsmStmtStorageClass[sizeOfActualPool] ;
30322 0 : inFile.read ( (char*) (storageArraySgAsmStmt) , sizeof ( SgAsmStmtStorageClass ) * sizeOfActualPool) ;
30323 0 : SgAsmStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
30324 : SgAsmStmtStorageClass* storageArray = storageArraySgAsmStmt;
30325 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30326 : {
30327 0 : SgAsmStmt* tmp = new SgAsmStmt ( *storageArray ) ;
30328 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30329 0 : storageArray++ ;
30330 : }
30331 : }
30332 0 : delete [] storageArraySgAsmStmt;
30333 2 : SgAsmStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
30334 :
30335 :
30336 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssertStmt );
30337 2 : SgAssertStmtStorageClass* storageArraySgAssertStmt = NULL;
30338 2 : if ( 0 < sizeOfActualPool )
30339 : {
30340 0 : storageArraySgAssertStmt = new SgAssertStmtStorageClass[sizeOfActualPool] ;
30341 0 : inFile.read ( (char*) (storageArraySgAssertStmt) , sizeof ( SgAssertStmtStorageClass ) * sizeOfActualPool) ;
30342 0 : SgAssertStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
30343 : SgAssertStmtStorageClass* storageArray = storageArraySgAssertStmt;
30344 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30345 : {
30346 0 : SgAssertStmt* tmp = new SgAssertStmt ( *storageArray ) ;
30347 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30348 0 : storageArray++ ;
30349 : }
30350 : }
30351 0 : delete [] storageArraySgAssertStmt;
30352 2 : SgAssertStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
30353 :
30354 :
30355 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssignInitializer );
30356 2 : SgAssignInitializerStorageClass* storageArraySgAssignInitializer = NULL;
30357 2 : if ( 0 < sizeOfActualPool )
30358 : {
30359 1194 : storageArraySgAssignInitializer = new SgAssignInitializerStorageClass[sizeOfActualPool] ;
30360 1 : inFile.read ( (char*) (storageArraySgAssignInitializer) , sizeof ( SgAssignInitializerStorageClass ) * sizeOfActualPool) ;
30361 1 : SgAssignInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
30362 : SgAssignInitializerStorageClass* storageArray = storageArraySgAssignInitializer;
30363 1194 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30364 : {
30365 1193 : SgAssignInitializer* tmp = new SgAssignInitializer ( *storageArray ) ;
30366 1193 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30367 1193 : storageArray++ ;
30368 : }
30369 : }
30370 1 : delete [] storageArraySgAssignInitializer;
30371 2 : SgAssignInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
30372 :
30373 :
30374 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssignOp );
30375 2 : SgAssignOpStorageClass* storageArraySgAssignOp = NULL;
30376 2 : if ( 0 < sizeOfActualPool )
30377 : {
30378 456 : storageArraySgAssignOp = new SgAssignOpStorageClass[sizeOfActualPool] ;
30379 1 : inFile.read ( (char*) (storageArraySgAssignOp) , sizeof ( SgAssignOpStorageClass ) * sizeOfActualPool) ;
30380 1 : SgAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30381 : SgAssignOpStorageClass* storageArray = storageArraySgAssignOp;
30382 456 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30383 : {
30384 455 : SgAssignOp* tmp = new SgAssignOp ( *storageArray ) ;
30385 455 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30386 455 : storageArray++ ;
30387 : }
30388 : }
30389 1 : delete [] storageArraySgAssignOp;
30390 2 : SgAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30391 :
30392 :
30393 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssignStatement );
30394 2 : SgAssignStatementStorageClass* storageArraySgAssignStatement = NULL;
30395 2 : if ( 0 < sizeOfActualPool )
30396 : {
30397 0 : storageArraySgAssignStatement = new SgAssignStatementStorageClass[sizeOfActualPool] ;
30398 0 : inFile.read ( (char*) (storageArraySgAssignStatement) , sizeof ( SgAssignStatementStorageClass ) * sizeOfActualPool) ;
30399 0 : SgAssignStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30400 : SgAssignStatementStorageClass* storageArray = storageArraySgAssignStatement;
30401 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30402 : {
30403 0 : SgAssignStatement* tmp = new SgAssignStatement ( *storageArray ) ;
30404 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30405 0 : storageArray++ ;
30406 : }
30407 : }
30408 0 : delete [] storageArraySgAssignStatement;
30409 2 : SgAssignStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30410 :
30411 :
30412 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssignedGotoStatement );
30413 2 : SgAssignedGotoStatementStorageClass* storageArraySgAssignedGotoStatement = NULL;
30414 2 : if ( 0 < sizeOfActualPool )
30415 : {
30416 0 : storageArraySgAssignedGotoStatement = new SgAssignedGotoStatementStorageClass[sizeOfActualPool] ;
30417 0 : inFile.read ( (char*) (storageArraySgAssignedGotoStatement) , sizeof ( SgAssignedGotoStatementStorageClass ) * sizeOfActualPool) ;
30418 0 : SgAssignedGotoStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30419 : SgAssignedGotoStatementStorageClass* storageArray = storageArraySgAssignedGotoStatement;
30420 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30421 : {
30422 0 : SgAssignedGotoStatement* tmp = new SgAssignedGotoStatement ( *storageArray ) ;
30423 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30424 0 : storageArray++ ;
30425 : }
30426 : }
30427 0 : delete [] storageArraySgAssignedGotoStatement;
30428 2 : SgAssignedGotoStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30429 :
30430 :
30431 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAssociateStatement );
30432 2 : SgAssociateStatementStorageClass* storageArraySgAssociateStatement = NULL;
30433 2 : if ( 0 < sizeOfActualPool )
30434 : {
30435 0 : storageArraySgAssociateStatement = new SgAssociateStatementStorageClass[sizeOfActualPool] ;
30436 0 : inFile.read ( (char*) (storageArraySgAssociateStatement) , sizeof ( SgAssociateStatementStorageClass ) * sizeOfActualPool) ;
30437 0 : SgAssociateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30438 : SgAssociateStatementStorageClass* storageArray = storageArraySgAssociateStatement;
30439 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30440 : {
30441 0 : SgAssociateStatement* tmp = new SgAssociateStatement ( *storageArray ) ;
30442 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30443 0 : storageArray++ ;
30444 : }
30445 : }
30446 0 : delete [] storageArraySgAssociateStatement;
30447 2 : SgAssociateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30448 :
30449 :
30450 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAsteriskShapeExp );
30451 2 : SgAsteriskShapeExpStorageClass* storageArraySgAsteriskShapeExp = NULL;
30452 2 : if ( 0 < sizeOfActualPool )
30453 : {
30454 0 : storageArraySgAsteriskShapeExp = new SgAsteriskShapeExpStorageClass[sizeOfActualPool] ;
30455 0 : inFile.read ( (char*) (storageArraySgAsteriskShapeExp) , sizeof ( SgAsteriskShapeExpStorageClass ) * sizeOfActualPool) ;
30456 0 : SgAsteriskShapeExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30457 : SgAsteriskShapeExpStorageClass* storageArray = storageArraySgAsteriskShapeExp;
30458 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30459 : {
30460 0 : SgAsteriskShapeExp* tmp = new SgAsteriskShapeExp ( *storageArray ) ;
30461 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30462 0 : storageArray++ ;
30463 : }
30464 : }
30465 0 : delete [] storageArraySgAsteriskShapeExp;
30466 2 : SgAsteriskShapeExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30467 :
30468 :
30469 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAttribute );
30470 2 : SgAttributeStorageClass* storageArraySgAttribute = NULL;
30471 2 : if ( 0 < sizeOfActualPool )
30472 : {
30473 0 : storageArraySgAttribute = new SgAttributeStorageClass[sizeOfActualPool] ;
30474 0 : inFile.read ( (char*) (storageArraySgAttribute) , sizeof ( SgAttributeStorageClass ) * sizeOfActualPool) ;
30475 0 : SgAttributeStorageClass :: readEasyStorageDataFromFile(inFile) ;
30476 : SgAttributeStorageClass* storageArray = storageArraySgAttribute;
30477 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30478 : {
30479 0 : SgAttribute* tmp = new SgAttribute ( *storageArray ) ;
30480 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30481 0 : storageArray++ ;
30482 : }
30483 : }
30484 0 : delete [] storageArraySgAttribute;
30485 2 : SgAttributeStorageClass :: deleteStaticDataOfEasyStorageClasses();
30486 :
30487 :
30488 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAttributeSpecificationStatement );
30489 2 : SgAttributeSpecificationStatementStorageClass* storageArraySgAttributeSpecificationStatement = NULL;
30490 2 : if ( 0 < sizeOfActualPool )
30491 : {
30492 0 : storageArraySgAttributeSpecificationStatement = new SgAttributeSpecificationStatementStorageClass[sizeOfActualPool] ;
30493 0 : inFile.read ( (char*) (storageArraySgAttributeSpecificationStatement) , sizeof ( SgAttributeSpecificationStatementStorageClass ) * sizeOfActualPool) ;
30494 0 : SgAttributeSpecificationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30495 : SgAttributeSpecificationStatementStorageClass* storageArray = storageArraySgAttributeSpecificationStatement;
30496 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30497 : {
30498 0 : SgAttributeSpecificationStatement* tmp = new SgAttributeSpecificationStatement ( *storageArray ) ;
30499 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30500 0 : storageArray++ ;
30501 : }
30502 : }
30503 0 : delete [] storageArraySgAttributeSpecificationStatement;
30504 2 : SgAttributeSpecificationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30505 :
30506 :
30507 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAutoType );
30508 2 : SgAutoTypeStorageClass* storageArraySgAutoType = NULL;
30509 2 : if ( 0 < sizeOfActualPool )
30510 : {
30511 15 : storageArraySgAutoType = new SgAutoTypeStorageClass[sizeOfActualPool] ;
30512 1 : inFile.read ( (char*) (storageArraySgAutoType) , sizeof ( SgAutoTypeStorageClass ) * sizeOfActualPool) ;
30513 1 : SgAutoTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
30514 : SgAutoTypeStorageClass* storageArray = storageArraySgAutoType;
30515 15 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30516 : {
30517 14 : SgAutoType* tmp = new SgAutoType ( *storageArray ) ;
30518 14 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30519 14 : storageArray++ ;
30520 : }
30521 : }
30522 1 : delete [] storageArraySgAutoType;
30523 2 : SgAutoTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
30524 :
30525 :
30526 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAwaitExpression );
30527 2 : SgAwaitExpressionStorageClass* storageArraySgAwaitExpression = NULL;
30528 2 : if ( 0 < sizeOfActualPool )
30529 : {
30530 0 : storageArraySgAwaitExpression = new SgAwaitExpressionStorageClass[sizeOfActualPool] ;
30531 0 : inFile.read ( (char*) (storageArraySgAwaitExpression) , sizeof ( SgAwaitExpressionStorageClass ) * sizeOfActualPool) ;
30532 0 : SgAwaitExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
30533 : SgAwaitExpressionStorageClass* storageArray = storageArraySgAwaitExpression;
30534 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30535 : {
30536 0 : SgAwaitExpression* tmp = new SgAwaitExpression ( *storageArray ) ;
30537 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30538 0 : storageArray++ ;
30539 : }
30540 : }
30541 0 : delete [] storageArraySgAwaitExpression;
30542 2 : SgAwaitExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
30543 :
30544 :
30545 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBackspaceStatement );
30546 2 : SgBackspaceStatementStorageClass* storageArraySgBackspaceStatement = NULL;
30547 2 : if ( 0 < sizeOfActualPool )
30548 : {
30549 0 : storageArraySgBackspaceStatement = new SgBackspaceStatementStorageClass[sizeOfActualPool] ;
30550 0 : inFile.read ( (char*) (storageArraySgBackspaceStatement) , sizeof ( SgBackspaceStatementStorageClass ) * sizeOfActualPool) ;
30551 0 : SgBackspaceStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30552 : SgBackspaceStatementStorageClass* storageArray = storageArraySgBackspaceStatement;
30553 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30554 : {
30555 0 : SgBackspaceStatement* tmp = new SgBackspaceStatement ( *storageArray ) ;
30556 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30557 0 : storageArray++ ;
30558 : }
30559 : }
30560 0 : delete [] storageArraySgBackspaceStatement;
30561 2 : SgBackspaceStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30562 :
30563 :
30564 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBaseClass );
30565 2 : SgBaseClassStorageClass* storageArraySgBaseClass = NULL;
30566 2 : if ( 0 < sizeOfActualPool )
30567 : {
30568 1 : storageArraySgBaseClass = new SgBaseClassStorageClass[sizeOfActualPool] ;
30569 1 : inFile.read ( (char*) (storageArraySgBaseClass) , sizeof ( SgBaseClassStorageClass ) * sizeOfActualPool) ;
30570 : SgBaseClassStorageClass* storageArray = storageArraySgBaseClass;
30571 421 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30572 : {
30573 420 : SgBaseClass* tmp = new SgBaseClass ( *storageArray ) ;
30574 420 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30575 420 : storageArray++ ;
30576 : }
30577 : }
30578 1 : delete [] storageArraySgBaseClass;
30579 :
30580 :
30581 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExpBaseClass );
30582 2 : SgExpBaseClassStorageClass* storageArraySgExpBaseClass = NULL;
30583 2 : if ( 0 < sizeOfActualPool )
30584 : {
30585 0 : storageArraySgExpBaseClass = new SgExpBaseClassStorageClass[sizeOfActualPool] ;
30586 0 : inFile.read ( (char*) (storageArraySgExpBaseClass) , sizeof ( SgExpBaseClassStorageClass ) * sizeOfActualPool) ;
30587 : SgExpBaseClassStorageClass* storageArray = storageArraySgExpBaseClass;
30588 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30589 : {
30590 0 : SgExpBaseClass* tmp = new SgExpBaseClass ( *storageArray ) ;
30591 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30592 0 : storageArray++ ;
30593 : }
30594 : }
30595 0 : delete [] storageArraySgExpBaseClass;
30596 :
30597 :
30598 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBaseClassModifier );
30599 2 : SgBaseClassModifierStorageClass* storageArraySgBaseClassModifier = NULL;
30600 2 : if ( 0 < sizeOfActualPool )
30601 : {
30602 1 : storageArraySgBaseClassModifier = new SgBaseClassModifierStorageClass[sizeOfActualPool] ;
30603 1 : inFile.read ( (char*) (storageArraySgBaseClassModifier) , sizeof ( SgBaseClassModifierStorageClass ) * sizeOfActualPool) ;
30604 1 : SgBaseClassModifierStorageClass :: readEasyStorageDataFromFile(inFile) ;
30605 : SgBaseClassModifierStorageClass* storageArray = storageArraySgBaseClassModifier;
30606 621 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30607 : {
30608 620 : SgBaseClassModifier* tmp = new SgBaseClassModifier ( *storageArray ) ;
30609 620 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30610 620 : storageArray++ ;
30611 : }
30612 : }
30613 1 : delete [] storageArraySgBaseClassModifier;
30614 2 : SgBaseClassModifierStorageClass :: deleteStaticDataOfEasyStorageClasses();
30615 :
30616 :
30617 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBasicBlock );
30618 2 : SgBasicBlockStorageClass* storageArraySgBasicBlock = NULL;
30619 2 : if ( 0 < sizeOfActualPool )
30620 : {
30621 2867 : storageArraySgBasicBlock = new SgBasicBlockStorageClass[sizeOfActualPool] ;
30622 2 : inFile.read ( (char*) (storageArraySgBasicBlock) , sizeof ( SgBasicBlockStorageClass ) * sizeOfActualPool) ;
30623 2 : SgBasicBlockStorageClass :: readEasyStorageDataFromFile(inFile) ;
30624 : SgBasicBlockStorageClass* storageArray = storageArraySgBasicBlock;
30625 2867 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30626 : {
30627 2865 : SgBasicBlock* tmp = new SgBasicBlock ( *storageArray ) ;
30628 2865 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30629 2865 : storageArray++ ;
30630 : }
30631 : }
30632 2 : delete [] storageArraySgBasicBlock;
30633 2 : SgBasicBlockStorageClass :: deleteStaticDataOfEasyStorageClasses();
30634 :
30635 :
30636 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBidirectionalGraph );
30637 2 : SgBidirectionalGraphStorageClass* storageArraySgBidirectionalGraph = NULL;
30638 2 : if ( 0 < sizeOfActualPool )
30639 : {
30640 0 : storageArraySgBidirectionalGraph = new SgBidirectionalGraphStorageClass[sizeOfActualPool] ;
30641 0 : inFile.read ( (char*) (storageArraySgBidirectionalGraph) , sizeof ( SgBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
30642 0 : SgBidirectionalGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
30643 : SgBidirectionalGraphStorageClass* storageArray = storageArraySgBidirectionalGraph;
30644 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30645 : {
30646 0 : SgBidirectionalGraph* tmp = new SgBidirectionalGraph ( *storageArray ) ;
30647 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30648 0 : storageArray++ ;
30649 : }
30650 : }
30651 0 : delete [] storageArraySgBidirectionalGraph;
30652 2 : SgBidirectionalGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
30653 :
30654 :
30655 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBinaryOp );
30656 2 : SgBinaryOpStorageClass* storageArraySgBinaryOp = NULL;
30657 2 : if ( 0 < sizeOfActualPool )
30658 : {
30659 0 : storageArraySgBinaryOp = new SgBinaryOpStorageClass[sizeOfActualPool] ;
30660 0 : inFile.read ( (char*) (storageArraySgBinaryOp) , sizeof ( SgBinaryOpStorageClass ) * sizeOfActualPool) ;
30661 0 : SgBinaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30662 : SgBinaryOpStorageClass* storageArray = storageArraySgBinaryOp;
30663 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30664 : {
30665 0 : SgBinaryOp* tmp = new SgBinaryOp ( *storageArray ) ;
30666 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30667 0 : storageArray++ ;
30668 : }
30669 : }
30670 0 : delete [] storageArraySgBinaryOp;
30671 2 : SgBinaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30672 :
30673 :
30674 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitAndOp );
30675 2 : SgBitAndOpStorageClass* storageArraySgBitAndOp = NULL;
30676 2 : if ( 0 < sizeOfActualPool )
30677 : {
30678 21 : storageArraySgBitAndOp = new SgBitAndOpStorageClass[sizeOfActualPool] ;
30679 1 : inFile.read ( (char*) (storageArraySgBitAndOp) , sizeof ( SgBitAndOpStorageClass ) * sizeOfActualPool) ;
30680 1 : SgBitAndOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30681 : SgBitAndOpStorageClass* storageArray = storageArraySgBitAndOp;
30682 21 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30683 : {
30684 20 : SgBitAndOp* tmp = new SgBitAndOp ( *storageArray ) ;
30685 20 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30686 20 : storageArray++ ;
30687 : }
30688 : }
30689 1 : delete [] storageArraySgBitAndOp;
30690 2 : SgBitAndOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30691 :
30692 :
30693 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitAttribute );
30694 2 : SgBitAttributeStorageClass* storageArraySgBitAttribute = NULL;
30695 2 : if ( 0 < sizeOfActualPool )
30696 : {
30697 0 : storageArraySgBitAttribute = new SgBitAttributeStorageClass[sizeOfActualPool] ;
30698 0 : inFile.read ( (char*) (storageArraySgBitAttribute) , sizeof ( SgBitAttributeStorageClass ) * sizeOfActualPool) ;
30699 0 : SgBitAttributeStorageClass :: readEasyStorageDataFromFile(inFile) ;
30700 : SgBitAttributeStorageClass* storageArray = storageArraySgBitAttribute;
30701 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30702 : {
30703 0 : SgBitAttribute* tmp = new SgBitAttribute ( *storageArray ) ;
30704 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30705 0 : storageArray++ ;
30706 : }
30707 : }
30708 0 : delete [] storageArraySgBitAttribute;
30709 2 : SgBitAttributeStorageClass :: deleteStaticDataOfEasyStorageClasses();
30710 :
30711 :
30712 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitComplementOp );
30713 2 : SgBitComplementOpStorageClass* storageArraySgBitComplementOp = NULL;
30714 2 : if ( 0 < sizeOfActualPool )
30715 : {
30716 12 : storageArraySgBitComplementOp = new SgBitComplementOpStorageClass[sizeOfActualPool] ;
30717 1 : inFile.read ( (char*) (storageArraySgBitComplementOp) , sizeof ( SgBitComplementOpStorageClass ) * sizeOfActualPool) ;
30718 1 : SgBitComplementOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30719 : SgBitComplementOpStorageClass* storageArray = storageArraySgBitComplementOp;
30720 12 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30721 : {
30722 11 : SgBitComplementOp* tmp = new SgBitComplementOp ( *storageArray ) ;
30723 11 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30724 11 : storageArray++ ;
30725 : }
30726 : }
30727 1 : delete [] storageArraySgBitComplementOp;
30728 2 : SgBitComplementOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30729 :
30730 :
30731 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitEqvOp );
30732 2 : SgBitEqvOpStorageClass* storageArraySgBitEqvOp = NULL;
30733 2 : if ( 0 < sizeOfActualPool )
30734 : {
30735 0 : storageArraySgBitEqvOp = new SgBitEqvOpStorageClass[sizeOfActualPool] ;
30736 0 : inFile.read ( (char*) (storageArraySgBitEqvOp) , sizeof ( SgBitEqvOpStorageClass ) * sizeOfActualPool) ;
30737 0 : SgBitEqvOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30738 : SgBitEqvOpStorageClass* storageArray = storageArraySgBitEqvOp;
30739 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30740 : {
30741 0 : SgBitEqvOp* tmp = new SgBitEqvOp ( *storageArray ) ;
30742 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30743 0 : storageArray++ ;
30744 : }
30745 : }
30746 0 : delete [] storageArraySgBitEqvOp;
30747 2 : SgBitEqvOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30748 :
30749 :
30750 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitOrOp );
30751 2 : SgBitOrOpStorageClass* storageArraySgBitOrOp = NULL;
30752 2 : if ( 0 < sizeOfActualPool )
30753 : {
30754 16 : storageArraySgBitOrOp = new SgBitOrOpStorageClass[sizeOfActualPool] ;
30755 1 : inFile.read ( (char*) (storageArraySgBitOrOp) , sizeof ( SgBitOrOpStorageClass ) * sizeOfActualPool) ;
30756 1 : SgBitOrOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30757 : SgBitOrOpStorageClass* storageArray = storageArraySgBitOrOp;
30758 16 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30759 : {
30760 15 : SgBitOrOp* tmp = new SgBitOrOp ( *storageArray ) ;
30761 15 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30762 15 : storageArray++ ;
30763 : }
30764 : }
30765 1 : delete [] storageArraySgBitOrOp;
30766 2 : SgBitOrOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30767 :
30768 :
30769 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBitXorOp );
30770 2 : SgBitXorOpStorageClass* storageArraySgBitXorOp = NULL;
30771 2 : if ( 0 < sizeOfActualPool )
30772 : {
30773 7 : storageArraySgBitXorOp = new SgBitXorOpStorageClass[sizeOfActualPool] ;
30774 1 : inFile.read ( (char*) (storageArraySgBitXorOp) , sizeof ( SgBitXorOpStorageClass ) * sizeOfActualPool) ;
30775 1 : SgBitXorOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30776 : SgBitXorOpStorageClass* storageArray = storageArraySgBitXorOp;
30777 7 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30778 : {
30779 6 : SgBitXorOp* tmp = new SgBitXorOp ( *storageArray ) ;
30780 6 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30781 6 : storageArray++ ;
30782 : }
30783 : }
30784 1 : delete [] storageArraySgBitXorOp;
30785 2 : SgBitXorOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30786 :
30787 :
30788 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBlockDataStatement );
30789 2 : SgBlockDataStatementStorageClass* storageArraySgBlockDataStatement = NULL;
30790 2 : if ( 0 < sizeOfActualPool )
30791 : {
30792 0 : storageArraySgBlockDataStatement = new SgBlockDataStatementStorageClass[sizeOfActualPool] ;
30793 0 : inFile.read ( (char*) (storageArraySgBlockDataStatement) , sizeof ( SgBlockDataStatementStorageClass ) * sizeOfActualPool) ;
30794 0 : SgBlockDataStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30795 : SgBlockDataStatementStorageClass* storageArray = storageArraySgBlockDataStatement;
30796 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30797 : {
30798 0 : SgBlockDataStatement* tmp = new SgBlockDataStatement ( *storageArray ) ;
30799 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30800 0 : storageArray++ ;
30801 : }
30802 : }
30803 0 : delete [] storageArraySgBlockDataStatement;
30804 2 : SgBlockDataStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30805 :
30806 :
30807 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBoolValExp );
30808 2 : SgBoolValExpStorageClass* storageArraySgBoolValExp = NULL;
30809 2 : if ( 0 < sizeOfActualPool )
30810 : {
30811 399 : storageArraySgBoolValExp = new SgBoolValExpStorageClass[sizeOfActualPool] ;
30812 1 : inFile.read ( (char*) (storageArraySgBoolValExp) , sizeof ( SgBoolValExpStorageClass ) * sizeOfActualPool) ;
30813 1 : SgBoolValExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30814 : SgBoolValExpStorageClass* storageArray = storageArraySgBoolValExp;
30815 399 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30816 : {
30817 398 : SgBoolValExp* tmp = new SgBoolValExp ( *storageArray ) ;
30818 398 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30819 398 : storageArray++ ;
30820 : }
30821 : }
30822 1 : delete [] storageArraySgBoolValExp;
30823 2 : SgBoolValExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30824 :
30825 :
30826 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBreakStmt );
30827 2 : SgBreakStmtStorageClass* storageArraySgBreakStmt = NULL;
30828 2 : if ( 0 < sizeOfActualPool )
30829 : {
30830 31 : storageArraySgBreakStmt = new SgBreakStmtStorageClass[sizeOfActualPool] ;
30831 1 : inFile.read ( (char*) (storageArraySgBreakStmt) , sizeof ( SgBreakStmtStorageClass ) * sizeOfActualPool) ;
30832 1 : SgBreakStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
30833 : SgBreakStmtStorageClass* storageArray = storageArraySgBreakStmt;
30834 31 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30835 : {
30836 30 : SgBreakStmt* tmp = new SgBreakStmt ( *storageArray ) ;
30837 30 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30838 30 : storageArray++ ;
30839 : }
30840 : }
30841 1 : delete [] storageArraySgBreakStmt;
30842 2 : SgBreakStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
30843 :
30844 :
30845 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgBracedInitializer );
30846 2 : SgBracedInitializerStorageClass* storageArraySgBracedInitializer = NULL;
30847 2 : if ( 0 < sizeOfActualPool )
30848 : {
30849 2 : storageArraySgBracedInitializer = new SgBracedInitializerStorageClass[sizeOfActualPool] ;
30850 1 : inFile.read ( (char*) (storageArraySgBracedInitializer) , sizeof ( SgBracedInitializerStorageClass ) * sizeOfActualPool) ;
30851 1 : SgBracedInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
30852 : SgBracedInitializerStorageClass* storageArray = storageArraySgBracedInitializer;
30853 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30854 : {
30855 1 : SgBracedInitializer* tmp = new SgBracedInitializer ( *storageArray ) ;
30856 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30857 1 : storageArray++ ;
30858 : }
30859 : }
30860 1 : delete [] storageArraySgBracedInitializer;
30861 2 : SgBracedInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
30862 :
30863 :
30864 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgC_PreprocessorDirectiveStatement );
30865 2 : SgC_PreprocessorDirectiveStatementStorageClass* storageArraySgC_PreprocessorDirectiveStatement = NULL;
30866 2 : if ( 0 < sizeOfActualPool )
30867 : {
30868 0 : storageArraySgC_PreprocessorDirectiveStatement = new SgC_PreprocessorDirectiveStatementStorageClass[sizeOfActualPool] ;
30869 0 : inFile.read ( (char*) (storageArraySgC_PreprocessorDirectiveStatement) , sizeof ( SgC_PreprocessorDirectiveStatementStorageClass ) * sizeOfActualPool) ;
30870 0 : SgC_PreprocessorDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
30871 : SgC_PreprocessorDirectiveStatementStorageClass* storageArray = storageArraySgC_PreprocessorDirectiveStatement;
30872 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30873 : {
30874 0 : SgC_PreprocessorDirectiveStatement* tmp = new SgC_PreprocessorDirectiveStatement ( *storageArray ) ;
30875 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30876 0 : storageArray++ ;
30877 : }
30878 : }
30879 0 : delete [] storageArraySgC_PreprocessorDirectiveStatement;
30880 2 : SgC_PreprocessorDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
30881 :
30882 :
30883 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCaseOptionStmt );
30884 2 : SgCaseOptionStmtStorageClass* storageArraySgCaseOptionStmt = NULL;
30885 2 : if ( 0 < sizeOfActualPool )
30886 : {
30887 0 : storageArraySgCaseOptionStmt = new SgCaseOptionStmtStorageClass[sizeOfActualPool] ;
30888 0 : inFile.read ( (char*) (storageArraySgCaseOptionStmt) , sizeof ( SgCaseOptionStmtStorageClass ) * sizeOfActualPool) ;
30889 0 : SgCaseOptionStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
30890 : SgCaseOptionStmtStorageClass* storageArray = storageArraySgCaseOptionStmt;
30891 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30892 : {
30893 0 : SgCaseOptionStmt* tmp = new SgCaseOptionStmt ( *storageArray ) ;
30894 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30895 0 : storageArray++ ;
30896 : }
30897 : }
30898 0 : delete [] storageArraySgCaseOptionStmt;
30899 2 : SgCaseOptionStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
30900 :
30901 :
30902 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCastExp );
30903 2 : SgCastExpStorageClass* storageArraySgCastExp = NULL;
30904 2 : if ( 0 < sizeOfActualPool )
30905 : {
30906 2263 : storageArraySgCastExp = new SgCastExpStorageClass[sizeOfActualPool] ;
30907 2 : inFile.read ( (char*) (storageArraySgCastExp) , sizeof ( SgCastExpStorageClass ) * sizeOfActualPool) ;
30908 2 : SgCastExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
30909 : SgCastExpStorageClass* storageArray = storageArraySgCastExp;
30910 2263 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30911 : {
30912 2261 : SgCastExp* tmp = new SgCastExp ( *storageArray ) ;
30913 2261 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30914 2261 : storageArray++ ;
30915 : }
30916 : }
30917 2 : delete [] storageArraySgCastExp;
30918 2 : SgCastExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
30919 :
30920 :
30921 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCatchOptionStmt );
30922 2 : SgCatchOptionStmtStorageClass* storageArraySgCatchOptionStmt = NULL;
30923 2 : if ( 0 < sizeOfActualPool )
30924 : {
30925 91 : storageArraySgCatchOptionStmt = new SgCatchOptionStmtStorageClass[sizeOfActualPool] ;
30926 1 : inFile.read ( (char*) (storageArraySgCatchOptionStmt) , sizeof ( SgCatchOptionStmtStorageClass ) * sizeOfActualPool) ;
30927 1 : SgCatchOptionStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
30928 : SgCatchOptionStmtStorageClass* storageArray = storageArraySgCatchOptionStmt;
30929 91 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30930 : {
30931 90 : SgCatchOptionStmt* tmp = new SgCatchOptionStmt ( *storageArray ) ;
30932 90 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30933 90 : storageArray++ ;
30934 : }
30935 : }
30936 1 : delete [] storageArraySgCatchOptionStmt;
30937 2 : SgCatchOptionStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
30938 :
30939 :
30940 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCatchStatementSeq );
30941 2 : SgCatchStatementSeqStorageClass* storageArraySgCatchStatementSeq = NULL;
30942 2 : if ( 0 < sizeOfActualPool )
30943 : {
30944 55 : storageArraySgCatchStatementSeq = new SgCatchStatementSeqStorageClass[sizeOfActualPool] ;
30945 1 : inFile.read ( (char*) (storageArraySgCatchStatementSeq) , sizeof ( SgCatchStatementSeqStorageClass ) * sizeOfActualPool) ;
30946 1 : SgCatchStatementSeqStorageClass :: readEasyStorageDataFromFile(inFile) ;
30947 : SgCatchStatementSeqStorageClass* storageArray = storageArraySgCatchStatementSeq;
30948 55 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30949 : {
30950 54 : SgCatchStatementSeq* tmp = new SgCatchStatementSeq ( *storageArray ) ;
30951 54 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30952 54 : storageArray++ ;
30953 : }
30954 : }
30955 1 : delete [] storageArraySgCatchStatementSeq;
30956 2 : SgCatchStatementSeqStorageClass :: deleteStaticDataOfEasyStorageClasses();
30957 :
30958 :
30959 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCharVal );
30960 2 : SgCharValStorageClass* storageArraySgCharVal = NULL;
30961 2 : if ( 0 < sizeOfActualPool )
30962 : {
30963 48 : storageArraySgCharVal = new SgCharValStorageClass[sizeOfActualPool] ;
30964 1 : inFile.read ( (char*) (storageArraySgCharVal) , sizeof ( SgCharValStorageClass ) * sizeOfActualPool) ;
30965 1 : SgCharValStorageClass :: readEasyStorageDataFromFile(inFile) ;
30966 : SgCharValStorageClass* storageArray = storageArraySgCharVal;
30967 48 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30968 : {
30969 47 : SgCharVal* tmp = new SgCharVal ( *storageArray ) ;
30970 47 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30971 47 : storageArray++ ;
30972 : }
30973 : }
30974 1 : delete [] storageArraySgCharVal;
30975 2 : SgCharValStorageClass :: deleteStaticDataOfEasyStorageClasses();
30976 :
30977 :
30978 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgChar16Val );
30979 2 : SgChar16ValStorageClass* storageArraySgChar16Val = NULL;
30980 2 : if ( 0 < sizeOfActualPool )
30981 : {
30982 0 : storageArraySgChar16Val = new SgChar16ValStorageClass[sizeOfActualPool] ;
30983 0 : inFile.read ( (char*) (storageArraySgChar16Val) , sizeof ( SgChar16ValStorageClass ) * sizeOfActualPool) ;
30984 0 : SgChar16ValStorageClass :: readEasyStorageDataFromFile(inFile) ;
30985 : SgChar16ValStorageClass* storageArray = storageArraySgChar16Val;
30986 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
30987 : {
30988 0 : SgChar16Val* tmp = new SgChar16Val ( *storageArray ) ;
30989 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
30990 0 : storageArray++ ;
30991 : }
30992 : }
30993 0 : delete [] storageArraySgChar16Val;
30994 2 : SgChar16ValStorageClass :: deleteStaticDataOfEasyStorageClasses();
30995 :
30996 :
30997 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgChar32Val );
30998 2 : SgChar32ValStorageClass* storageArraySgChar32Val = NULL;
30999 2 : if ( 0 < sizeOfActualPool )
31000 : {
31001 0 : storageArraySgChar32Val = new SgChar32ValStorageClass[sizeOfActualPool] ;
31002 0 : inFile.read ( (char*) (storageArraySgChar32Val) , sizeof ( SgChar32ValStorageClass ) * sizeOfActualPool) ;
31003 0 : SgChar32ValStorageClass :: readEasyStorageDataFromFile(inFile) ;
31004 : SgChar32ValStorageClass* storageArray = storageArraySgChar32Val;
31005 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31006 : {
31007 0 : SgChar32Val* tmp = new SgChar32Val ( *storageArray ) ;
31008 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31009 0 : storageArray++ ;
31010 : }
31011 : }
31012 0 : delete [] storageArraySgChar32Val;
31013 2 : SgChar32ValStorageClass :: deleteStaticDataOfEasyStorageClasses();
31014 :
31015 :
31016 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgChooseExpression );
31017 2 : SgChooseExpressionStorageClass* storageArraySgChooseExpression = NULL;
31018 2 : if ( 0 < sizeOfActualPool )
31019 : {
31020 0 : storageArraySgChooseExpression = new SgChooseExpressionStorageClass[sizeOfActualPool] ;
31021 0 : inFile.read ( (char*) (storageArraySgChooseExpression) , sizeof ( SgChooseExpressionStorageClass ) * sizeOfActualPool) ;
31022 0 : SgChooseExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
31023 : SgChooseExpressionStorageClass* storageArray = storageArraySgChooseExpression;
31024 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31025 : {
31026 0 : SgChooseExpression* tmp = new SgChooseExpression ( *storageArray ) ;
31027 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31028 0 : storageArray++ ;
31029 : }
31030 : }
31031 0 : delete [] storageArraySgChooseExpression;
31032 2 : SgChooseExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
31033 :
31034 :
31035 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassDecl_attr );
31036 2 : SgClassDecl_attrStorageClass* storageArraySgClassDecl_attr = NULL;
31037 2 : if ( 0 < sizeOfActualPool )
31038 : {
31039 0 : storageArraySgClassDecl_attr = new SgClassDecl_attrStorageClass[sizeOfActualPool] ;
31040 0 : inFile.read ( (char*) (storageArraySgClassDecl_attr) , sizeof ( SgClassDecl_attrStorageClass ) * sizeOfActualPool) ;
31041 0 : SgClassDecl_attrStorageClass :: readEasyStorageDataFromFile(inFile) ;
31042 : SgClassDecl_attrStorageClass* storageArray = storageArraySgClassDecl_attr;
31043 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31044 : {
31045 0 : SgClassDecl_attr* tmp = new SgClassDecl_attr ( *storageArray ) ;
31046 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31047 0 : storageArray++ ;
31048 : }
31049 : }
31050 0 : delete [] storageArraySgClassDecl_attr;
31051 2 : SgClassDecl_attrStorageClass :: deleteStaticDataOfEasyStorageClasses();
31052 :
31053 :
31054 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassDeclaration );
31055 2 : SgClassDeclarationStorageClass* storageArraySgClassDeclaration = NULL;
31056 2 : if ( 0 < sizeOfActualPool )
31057 : {
31058 373 : storageArraySgClassDeclaration = new SgClassDeclarationStorageClass[sizeOfActualPool] ;
31059 2 : inFile.read ( (char*) (storageArraySgClassDeclaration) , sizeof ( SgClassDeclarationStorageClass ) * sizeOfActualPool) ;
31060 2 : SgClassDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
31061 : SgClassDeclarationStorageClass* storageArray = storageArraySgClassDeclaration;
31062 373 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31063 : {
31064 371 : SgClassDeclaration* tmp = new SgClassDeclaration ( *storageArray ) ;
31065 371 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31066 371 : storageArray++ ;
31067 : }
31068 : }
31069 2 : delete [] storageArraySgClassDeclaration;
31070 2 : SgClassDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
31071 :
31072 :
31073 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassDefinition );
31074 2 : SgClassDefinitionStorageClass* storageArraySgClassDefinition = NULL;
31075 2 : if ( 0 < sizeOfActualPool )
31076 : {
31077 170 : storageArraySgClassDefinition = new SgClassDefinitionStorageClass[sizeOfActualPool] ;
31078 2 : inFile.read ( (char*) (storageArraySgClassDefinition) , sizeof ( SgClassDefinitionStorageClass ) * sizeOfActualPool) ;
31079 2 : SgClassDefinitionStorageClass :: readEasyStorageDataFromFile(inFile) ;
31080 : SgClassDefinitionStorageClass* storageArray = storageArraySgClassDefinition;
31081 170 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31082 : {
31083 168 : SgClassDefinition* tmp = new SgClassDefinition ( *storageArray ) ;
31084 168 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31085 168 : storageArray++ ;
31086 : }
31087 : }
31088 2 : delete [] storageArraySgClassDefinition;
31089 2 : SgClassDefinitionStorageClass :: deleteStaticDataOfEasyStorageClasses();
31090 :
31091 :
31092 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassNameRefExp );
31093 2 : SgClassNameRefExpStorageClass* storageArraySgClassNameRefExp = NULL;
31094 2 : if ( 0 < sizeOfActualPool )
31095 : {
31096 0 : storageArraySgClassNameRefExp = new SgClassNameRefExpStorageClass[sizeOfActualPool] ;
31097 0 : inFile.read ( (char*) (storageArraySgClassNameRefExp) , sizeof ( SgClassNameRefExpStorageClass ) * sizeOfActualPool) ;
31098 0 : SgClassNameRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31099 : SgClassNameRefExpStorageClass* storageArray = storageArraySgClassNameRefExp;
31100 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31101 : {
31102 0 : SgClassNameRefExp* tmp = new SgClassNameRefExp ( *storageArray ) ;
31103 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31104 0 : storageArray++ ;
31105 : }
31106 : }
31107 0 : delete [] storageArraySgClassNameRefExp;
31108 2 : SgClassNameRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31109 :
31110 :
31111 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassSymbol );
31112 2 : SgClassSymbolStorageClass* storageArraySgClassSymbol = NULL;
31113 2 : if ( 0 < sizeOfActualPool )
31114 : {
31115 854 : storageArraySgClassSymbol = new SgClassSymbolStorageClass[sizeOfActualPool] ;
31116 2 : inFile.read ( (char*) (storageArraySgClassSymbol) , sizeof ( SgClassSymbolStorageClass ) * sizeOfActualPool) ;
31117 2 : SgClassSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
31118 : SgClassSymbolStorageClass* storageArray = storageArraySgClassSymbol;
31119 854 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31120 : {
31121 852 : SgClassSymbol* tmp = new SgClassSymbol ( *storageArray ) ;
31122 852 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31123 852 : storageArray++ ;
31124 : }
31125 : }
31126 2 : delete [] storageArraySgClassSymbol;
31127 2 : SgClassSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
31128 :
31129 :
31130 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassType );
31131 2 : SgClassTypeStorageClass* storageArraySgClassType = NULL;
31132 2 : if ( 0 < sizeOfActualPool )
31133 : {
31134 1403 : storageArraySgClassType = new SgClassTypeStorageClass[sizeOfActualPool] ;
31135 2 : inFile.read ( (char*) (storageArraySgClassType) , sizeof ( SgClassTypeStorageClass ) * sizeOfActualPool) ;
31136 2 : SgClassTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
31137 : SgClassTypeStorageClass* storageArray = storageArraySgClassType;
31138 1403 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31139 : {
31140 1401 : SgClassType* tmp = new SgClassType ( *storageArray ) ;
31141 1401 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31142 1401 : storageArray++ ;
31143 : }
31144 : }
31145 2 : delete [] storageArraySgClassType;
31146 2 : SgClassTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
31147 :
31148 :
31149 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClinkageDeclarationStatement );
31150 2 : SgClinkageDeclarationStatementStorageClass* storageArraySgClinkageDeclarationStatement = NULL;
31151 2 : if ( 0 < sizeOfActualPool )
31152 : {
31153 0 : storageArraySgClinkageDeclarationStatement = new SgClinkageDeclarationStatementStorageClass[sizeOfActualPool] ;
31154 0 : inFile.read ( (char*) (storageArraySgClinkageDeclarationStatement) , sizeof ( SgClinkageDeclarationStatementStorageClass ) * sizeOfActualPool) ;
31155 0 : SgClinkageDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31156 : SgClinkageDeclarationStatementStorageClass* storageArray = storageArraySgClinkageDeclarationStatement;
31157 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31158 : {
31159 0 : SgClinkageDeclarationStatement* tmp = new SgClinkageDeclarationStatement ( *storageArray ) ;
31160 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31161 0 : storageArray++ ;
31162 : }
31163 : }
31164 0 : delete [] storageArraySgClinkageDeclarationStatement;
31165 2 : SgClinkageDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31166 :
31167 :
31168 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClinkageEndStatement );
31169 2 : SgClinkageEndStatementStorageClass* storageArraySgClinkageEndStatement = NULL;
31170 2 : if ( 0 < sizeOfActualPool )
31171 : {
31172 0 : storageArraySgClinkageEndStatement = new SgClinkageEndStatementStorageClass[sizeOfActualPool] ;
31173 0 : inFile.read ( (char*) (storageArraySgClinkageEndStatement) , sizeof ( SgClinkageEndStatementStorageClass ) * sizeOfActualPool) ;
31174 0 : SgClinkageEndStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31175 : SgClinkageEndStatementStorageClass* storageArray = storageArraySgClinkageEndStatement;
31176 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31177 : {
31178 0 : SgClinkageEndStatement* tmp = new SgClinkageEndStatement ( *storageArray ) ;
31179 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31180 0 : storageArray++ ;
31181 : }
31182 : }
31183 0 : delete [] storageArraySgClinkageEndStatement;
31184 2 : SgClinkageEndStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31185 :
31186 :
31187 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClinkageStartStatement );
31188 2 : SgClinkageStartStatementStorageClass* storageArraySgClinkageStartStatement = NULL;
31189 2 : if ( 0 < sizeOfActualPool )
31190 : {
31191 0 : storageArraySgClinkageStartStatement = new SgClinkageStartStatementStorageClass[sizeOfActualPool] ;
31192 0 : inFile.read ( (char*) (storageArraySgClinkageStartStatement) , sizeof ( SgClinkageStartStatementStorageClass ) * sizeOfActualPool) ;
31193 0 : SgClinkageStartStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31194 : SgClinkageStartStatementStorageClass* storageArray = storageArraySgClinkageStartStatement;
31195 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31196 : {
31197 0 : SgClinkageStartStatement* tmp = new SgClinkageStartStatement ( *storageArray ) ;
31198 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31199 0 : storageArray++ ;
31200 : }
31201 : }
31202 0 : delete [] storageArraySgClinkageStartStatement;
31203 2 : SgClinkageStartStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31204 :
31205 :
31206 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCloseStatement );
31207 2 : SgCloseStatementStorageClass* storageArraySgCloseStatement = NULL;
31208 2 : if ( 0 < sizeOfActualPool )
31209 : {
31210 0 : storageArraySgCloseStatement = new SgCloseStatementStorageClass[sizeOfActualPool] ;
31211 0 : inFile.read ( (char*) (storageArraySgCloseStatement) , sizeof ( SgCloseStatementStorageClass ) * sizeOfActualPool) ;
31212 0 : SgCloseStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31213 : SgCloseStatementStorageClass* storageArray = storageArraySgCloseStatement;
31214 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31215 : {
31216 0 : SgCloseStatement* tmp = new SgCloseStatement ( *storageArray ) ;
31217 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31218 0 : storageArray++ ;
31219 : }
31220 : }
31221 0 : delete [] storageArraySgCloseStatement;
31222 2 : SgCloseStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31223 :
31224 :
31225 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgColonShapeExp );
31226 2 : SgColonShapeExpStorageClass* storageArraySgColonShapeExp = NULL;
31227 2 : if ( 0 < sizeOfActualPool )
31228 : {
31229 0 : storageArraySgColonShapeExp = new SgColonShapeExpStorageClass[sizeOfActualPool] ;
31230 0 : inFile.read ( (char*) (storageArraySgColonShapeExp) , sizeof ( SgColonShapeExpStorageClass ) * sizeOfActualPool) ;
31231 0 : SgColonShapeExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31232 : SgColonShapeExpStorageClass* storageArray = storageArraySgColonShapeExp;
31233 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31234 : {
31235 0 : SgColonShapeExp* tmp = new SgColonShapeExp ( *storageArray ) ;
31236 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31237 0 : storageArray++ ;
31238 : }
31239 : }
31240 0 : delete [] storageArraySgColonShapeExp;
31241 2 : SgColonShapeExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31242 :
31243 :
31244 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCommaOpExp );
31245 2 : SgCommaOpExpStorageClass* storageArraySgCommaOpExp = NULL;
31246 2 : if ( 0 < sizeOfActualPool )
31247 : {
31248 17 : storageArraySgCommaOpExp = new SgCommaOpExpStorageClass[sizeOfActualPool] ;
31249 1 : inFile.read ( (char*) (storageArraySgCommaOpExp) , sizeof ( SgCommaOpExpStorageClass ) * sizeOfActualPool) ;
31250 1 : SgCommaOpExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31251 : SgCommaOpExpStorageClass* storageArray = storageArraySgCommaOpExp;
31252 17 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31253 : {
31254 16 : SgCommaOpExp* tmp = new SgCommaOpExp ( *storageArray ) ;
31255 16 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31256 16 : storageArray++ ;
31257 : }
31258 : }
31259 1 : delete [] storageArraySgCommaOpExp;
31260 2 : SgCommaOpExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31261 :
31262 :
31263 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCommonBlock );
31264 2 : SgCommonBlockStorageClass* storageArraySgCommonBlock = NULL;
31265 2 : if ( 0 < sizeOfActualPool )
31266 : {
31267 0 : storageArraySgCommonBlock = new SgCommonBlockStorageClass[sizeOfActualPool] ;
31268 0 : inFile.read ( (char*) (storageArraySgCommonBlock) , sizeof ( SgCommonBlockStorageClass ) * sizeOfActualPool) ;
31269 0 : SgCommonBlockStorageClass :: readEasyStorageDataFromFile(inFile) ;
31270 : SgCommonBlockStorageClass* storageArray = storageArraySgCommonBlock;
31271 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31272 : {
31273 0 : SgCommonBlock* tmp = new SgCommonBlock ( *storageArray ) ;
31274 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31275 0 : storageArray++ ;
31276 : }
31277 : }
31278 0 : delete [] storageArraySgCommonBlock;
31279 2 : SgCommonBlockStorageClass :: deleteStaticDataOfEasyStorageClasses();
31280 :
31281 :
31282 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCommonBlockObject );
31283 2 : SgCommonBlockObjectStorageClass* storageArraySgCommonBlockObject = NULL;
31284 2 : if ( 0 < sizeOfActualPool )
31285 : {
31286 0 : storageArraySgCommonBlockObject = new SgCommonBlockObjectStorageClass[sizeOfActualPool] ;
31287 0 : inFile.read ( (char*) (storageArraySgCommonBlockObject) , sizeof ( SgCommonBlockObjectStorageClass ) * sizeOfActualPool) ;
31288 0 : SgCommonBlockObjectStorageClass :: readEasyStorageDataFromFile(inFile) ;
31289 : SgCommonBlockObjectStorageClass* storageArray = storageArraySgCommonBlockObject;
31290 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31291 : {
31292 0 : SgCommonBlockObject* tmp = new SgCommonBlockObject ( *storageArray ) ;
31293 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31294 0 : storageArray++ ;
31295 : }
31296 : }
31297 0 : delete [] storageArraySgCommonBlockObject;
31298 2 : SgCommonBlockObjectStorageClass :: deleteStaticDataOfEasyStorageClasses();
31299 :
31300 :
31301 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCommonSymbol );
31302 2 : SgCommonSymbolStorageClass* storageArraySgCommonSymbol = NULL;
31303 2 : if ( 0 < sizeOfActualPool )
31304 : {
31305 0 : storageArraySgCommonSymbol = new SgCommonSymbolStorageClass[sizeOfActualPool] ;
31306 0 : inFile.read ( (char*) (storageArraySgCommonSymbol) , sizeof ( SgCommonSymbolStorageClass ) * sizeOfActualPool) ;
31307 0 : SgCommonSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
31308 : SgCommonSymbolStorageClass* storageArray = storageArraySgCommonSymbol;
31309 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31310 : {
31311 0 : SgCommonSymbol* tmp = new SgCommonSymbol ( *storageArray ) ;
31312 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31313 0 : storageArray++ ;
31314 : }
31315 : }
31316 0 : delete [] storageArraySgCommonSymbol;
31317 2 : SgCommonSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
31318 :
31319 :
31320 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgComplexVal );
31321 2 : SgComplexValStorageClass* storageArraySgComplexVal = NULL;
31322 2 : if ( 0 < sizeOfActualPool )
31323 : {
31324 0 : storageArraySgComplexVal = new SgComplexValStorageClass[sizeOfActualPool] ;
31325 0 : inFile.read ( (char*) (storageArraySgComplexVal) , sizeof ( SgComplexValStorageClass ) * sizeOfActualPool) ;
31326 0 : SgComplexValStorageClass :: readEasyStorageDataFromFile(inFile) ;
31327 : SgComplexValStorageClass* storageArray = storageArraySgComplexVal;
31328 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31329 : {
31330 0 : SgComplexVal* tmp = new SgComplexVal ( *storageArray ) ;
31331 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31332 0 : storageArray++ ;
31333 : }
31334 : }
31335 0 : delete [] storageArraySgComplexVal;
31336 2 : SgComplexValStorageClass :: deleteStaticDataOfEasyStorageClasses();
31337 :
31338 :
31339 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgComprehension );
31340 2 : SgComprehensionStorageClass* storageArraySgComprehension = NULL;
31341 2 : if ( 0 < sizeOfActualPool )
31342 : {
31343 0 : storageArraySgComprehension = new SgComprehensionStorageClass[sizeOfActualPool] ;
31344 0 : inFile.read ( (char*) (storageArraySgComprehension) , sizeof ( SgComprehensionStorageClass ) * sizeOfActualPool) ;
31345 0 : SgComprehensionStorageClass :: readEasyStorageDataFromFile(inFile) ;
31346 : SgComprehensionStorageClass* storageArray = storageArraySgComprehension;
31347 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31348 : {
31349 0 : SgComprehension* tmp = new SgComprehension ( *storageArray ) ;
31350 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31351 0 : storageArray++ ;
31352 : }
31353 : }
31354 0 : delete [] storageArraySgComprehension;
31355 2 : SgComprehensionStorageClass :: deleteStaticDataOfEasyStorageClasses();
31356 :
31357 :
31358 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCompoundAssignOp );
31359 2 : SgCompoundAssignOpStorageClass* storageArraySgCompoundAssignOp = NULL;
31360 2 : if ( 0 < sizeOfActualPool )
31361 : {
31362 0 : storageArraySgCompoundAssignOp = new SgCompoundAssignOpStorageClass[sizeOfActualPool] ;
31363 0 : inFile.read ( (char*) (storageArraySgCompoundAssignOp) , sizeof ( SgCompoundAssignOpStorageClass ) * sizeOfActualPool) ;
31364 0 : SgCompoundAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31365 : SgCompoundAssignOpStorageClass* storageArray = storageArraySgCompoundAssignOp;
31366 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31367 : {
31368 0 : SgCompoundAssignOp* tmp = new SgCompoundAssignOp ( *storageArray ) ;
31369 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31370 0 : storageArray++ ;
31371 : }
31372 : }
31373 0 : delete [] storageArraySgCompoundAssignOp;
31374 2 : SgCompoundAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31375 :
31376 :
31377 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCompoundInitializer );
31378 2 : SgCompoundInitializerStorageClass* storageArraySgCompoundInitializer = NULL;
31379 2 : if ( 0 < sizeOfActualPool )
31380 : {
31381 0 : storageArraySgCompoundInitializer = new SgCompoundInitializerStorageClass[sizeOfActualPool] ;
31382 0 : inFile.read ( (char*) (storageArraySgCompoundInitializer) , sizeof ( SgCompoundInitializerStorageClass ) * sizeOfActualPool) ;
31383 0 : SgCompoundInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
31384 : SgCompoundInitializerStorageClass* storageArray = storageArraySgCompoundInitializer;
31385 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31386 : {
31387 0 : SgCompoundInitializer* tmp = new SgCompoundInitializer ( *storageArray ) ;
31388 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31389 0 : storageArray++ ;
31390 : }
31391 : }
31392 0 : delete [] storageArraySgCompoundInitializer;
31393 2 : SgCompoundInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
31394 :
31395 :
31396 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCompoundLiteralExp );
31397 2 : SgCompoundLiteralExpStorageClass* storageArraySgCompoundLiteralExp = NULL;
31398 2 : if ( 0 < sizeOfActualPool )
31399 : {
31400 0 : storageArraySgCompoundLiteralExp = new SgCompoundLiteralExpStorageClass[sizeOfActualPool] ;
31401 0 : inFile.read ( (char*) (storageArraySgCompoundLiteralExp) , sizeof ( SgCompoundLiteralExpStorageClass ) * sizeOfActualPool) ;
31402 0 : SgCompoundLiteralExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31403 : SgCompoundLiteralExpStorageClass* storageArray = storageArraySgCompoundLiteralExp;
31404 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31405 : {
31406 0 : SgCompoundLiteralExp* tmp = new SgCompoundLiteralExp ( *storageArray ) ;
31407 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31408 0 : storageArray++ ;
31409 : }
31410 : }
31411 0 : delete [] storageArraySgCompoundLiteralExp;
31412 2 : SgCompoundLiteralExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31413 :
31414 :
31415 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgComputedGotoStatement );
31416 2 : SgComputedGotoStatementStorageClass* storageArraySgComputedGotoStatement = NULL;
31417 2 : if ( 0 < sizeOfActualPool )
31418 : {
31419 0 : storageArraySgComputedGotoStatement = new SgComputedGotoStatementStorageClass[sizeOfActualPool] ;
31420 0 : inFile.read ( (char*) (storageArraySgComputedGotoStatement) , sizeof ( SgComputedGotoStatementStorageClass ) * sizeOfActualPool) ;
31421 0 : SgComputedGotoStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31422 : SgComputedGotoStatementStorageClass* storageArray = storageArraySgComputedGotoStatement;
31423 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31424 : {
31425 0 : SgComputedGotoStatement* tmp = new SgComputedGotoStatement ( *storageArray ) ;
31426 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31427 0 : storageArray++ ;
31428 : }
31429 : }
31430 0 : delete [] storageArraySgComputedGotoStatement;
31431 2 : SgComputedGotoStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31432 :
31433 :
31434 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgConcatenationOp );
31435 2 : SgConcatenationOpStorageClass* storageArraySgConcatenationOp = NULL;
31436 2 : if ( 0 < sizeOfActualPool )
31437 : {
31438 0 : storageArraySgConcatenationOp = new SgConcatenationOpStorageClass[sizeOfActualPool] ;
31439 0 : inFile.read ( (char*) (storageArraySgConcatenationOp) , sizeof ( SgConcatenationOpStorageClass ) * sizeOfActualPool) ;
31440 0 : SgConcatenationOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31441 : SgConcatenationOpStorageClass* storageArray = storageArraySgConcatenationOp;
31442 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31443 : {
31444 0 : SgConcatenationOp* tmp = new SgConcatenationOp ( *storageArray ) ;
31445 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31446 0 : storageArray++ ;
31447 : }
31448 : }
31449 0 : delete [] storageArraySgConcatenationOp;
31450 2 : SgConcatenationOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31451 :
31452 :
31453 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgConditionalExp );
31454 2 : SgConditionalExpStorageClass* storageArraySgConditionalExp = NULL;
31455 2 : if ( 0 < sizeOfActualPool )
31456 : {
31457 72 : storageArraySgConditionalExp = new SgConditionalExpStorageClass[sizeOfActualPool] ;
31458 1 : inFile.read ( (char*) (storageArraySgConditionalExp) , sizeof ( SgConditionalExpStorageClass ) * sizeOfActualPool) ;
31459 1 : SgConditionalExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31460 : SgConditionalExpStorageClass* storageArray = storageArraySgConditionalExp;
31461 72 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31462 : {
31463 71 : SgConditionalExp* tmp = new SgConditionalExp ( *storageArray ) ;
31464 71 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31465 71 : storageArray++ ;
31466 : }
31467 : }
31468 1 : delete [] storageArraySgConditionalExp;
31469 2 : SgConditionalExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31470 :
31471 :
31472 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgConjugateOp );
31473 2 : SgConjugateOpStorageClass* storageArraySgConjugateOp = NULL;
31474 2 : if ( 0 < sizeOfActualPool )
31475 : {
31476 0 : storageArraySgConjugateOp = new SgConjugateOpStorageClass[sizeOfActualPool] ;
31477 0 : inFile.read ( (char*) (storageArraySgConjugateOp) , sizeof ( SgConjugateOpStorageClass ) * sizeOfActualPool) ;
31478 0 : SgConjugateOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31479 : SgConjugateOpStorageClass* storageArray = storageArraySgConjugateOp;
31480 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31481 : {
31482 0 : SgConjugateOp* tmp = new SgConjugateOp ( *storageArray ) ;
31483 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31484 0 : storageArray++ ;
31485 : }
31486 : }
31487 0 : delete [] storageArraySgConjugateOp;
31488 2 : SgConjugateOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31489 :
31490 :
31491 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgConstVolatileModifier );
31492 2 : SgConstVolatileModifierStorageClass* storageArraySgConstVolatileModifier = NULL;
31493 2 : if ( 0 < sizeOfActualPool )
31494 : {
31495 0 : storageArraySgConstVolatileModifier = new SgConstVolatileModifierStorageClass[sizeOfActualPool] ;
31496 0 : inFile.read ( (char*) (storageArraySgConstVolatileModifier) , sizeof ( SgConstVolatileModifierStorageClass ) * sizeOfActualPool) ;
31497 : SgConstVolatileModifierStorageClass* storageArray = storageArraySgConstVolatileModifier;
31498 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31499 : {
31500 0 : SgConstVolatileModifier* tmp = new SgConstVolatileModifier ( *storageArray ) ;
31501 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31502 0 : storageArray++ ;
31503 : }
31504 : }
31505 0 : delete [] storageArraySgConstVolatileModifier;
31506 :
31507 :
31508 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgConstructorInitializer );
31509 2 : SgConstructorInitializerStorageClass* storageArraySgConstructorInitializer = NULL;
31510 2 : if ( 0 < sizeOfActualPool )
31511 : {
31512 462 : storageArraySgConstructorInitializer = new SgConstructorInitializerStorageClass[sizeOfActualPool] ;
31513 1 : inFile.read ( (char*) (storageArraySgConstructorInitializer) , sizeof ( SgConstructorInitializerStorageClass ) * sizeOfActualPool) ;
31514 1 : SgConstructorInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
31515 : SgConstructorInitializerStorageClass* storageArray = storageArraySgConstructorInitializer;
31516 462 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31517 : {
31518 461 : SgConstructorInitializer* tmp = new SgConstructorInitializer ( *storageArray ) ;
31519 461 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31520 461 : storageArray++ ;
31521 : }
31522 : }
31523 1 : delete [] storageArraySgConstructorInitializer;
31524 2 : SgConstructorInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
31525 :
31526 :
31527 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgContainsStatement );
31528 2 : SgContainsStatementStorageClass* storageArraySgContainsStatement = NULL;
31529 2 : if ( 0 < sizeOfActualPool )
31530 : {
31531 0 : storageArraySgContainsStatement = new SgContainsStatementStorageClass[sizeOfActualPool] ;
31532 0 : inFile.read ( (char*) (storageArraySgContainsStatement) , sizeof ( SgContainsStatementStorageClass ) * sizeOfActualPool) ;
31533 0 : SgContainsStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31534 : SgContainsStatementStorageClass* storageArray = storageArraySgContainsStatement;
31535 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31536 : {
31537 0 : SgContainsStatement* tmp = new SgContainsStatement ( *storageArray ) ;
31538 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31539 0 : storageArray++ ;
31540 : }
31541 : }
31542 0 : delete [] storageArraySgContainsStatement;
31543 2 : SgContainsStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31544 :
31545 :
31546 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgContinueStmt );
31547 2 : SgContinueStmtStorageClass* storageArraySgContinueStmt = NULL;
31548 2 : if ( 0 < sizeOfActualPool )
31549 : {
31550 3 : storageArraySgContinueStmt = new SgContinueStmtStorageClass[sizeOfActualPool] ;
31551 1 : inFile.read ( (char*) (storageArraySgContinueStmt) , sizeof ( SgContinueStmtStorageClass ) * sizeOfActualPool) ;
31552 1 : SgContinueStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
31553 : SgContinueStmtStorageClass* storageArray = storageArraySgContinueStmt;
31554 3 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31555 : {
31556 2 : SgContinueStmt* tmp = new SgContinueStmt ( *storageArray ) ;
31557 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31558 2 : storageArray++ ;
31559 : }
31560 : }
31561 1 : delete [] storageArraySgContinueStmt;
31562 2 : SgContinueStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
31563 :
31564 :
31565 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCtorInitializerList );
31566 2 : SgCtorInitializerListStorageClass* storageArraySgCtorInitializerList = NULL;
31567 2 : if ( 0 < sizeOfActualPool )
31568 : {
31569 4429 : storageArraySgCtorInitializerList = new SgCtorInitializerListStorageClass[sizeOfActualPool] ;
31570 1 : inFile.read ( (char*) (storageArraySgCtorInitializerList) , sizeof ( SgCtorInitializerListStorageClass ) * sizeOfActualPool) ;
31571 1 : SgCtorInitializerListStorageClass :: readEasyStorageDataFromFile(inFile) ;
31572 : SgCtorInitializerListStorageClass* storageArray = storageArraySgCtorInitializerList;
31573 4429 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31574 : {
31575 4428 : SgCtorInitializerList* tmp = new SgCtorInitializerList ( *storageArray ) ;
31576 4428 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31577 4428 : storageArray++ ;
31578 : }
31579 : }
31580 1 : delete [] storageArraySgCtorInitializerList;
31581 2 : SgCtorInitializerListStorageClass :: deleteStaticDataOfEasyStorageClasses();
31582 :
31583 :
31584 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDataStatementGroup );
31585 2 : SgDataStatementGroupStorageClass* storageArraySgDataStatementGroup = NULL;
31586 2 : if ( 0 < sizeOfActualPool )
31587 : {
31588 0 : storageArraySgDataStatementGroup = new SgDataStatementGroupStorageClass[sizeOfActualPool] ;
31589 0 : inFile.read ( (char*) (storageArraySgDataStatementGroup) , sizeof ( SgDataStatementGroupStorageClass ) * sizeOfActualPool) ;
31590 0 : SgDataStatementGroupStorageClass :: readEasyStorageDataFromFile(inFile) ;
31591 : SgDataStatementGroupStorageClass* storageArray = storageArraySgDataStatementGroup;
31592 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31593 : {
31594 0 : SgDataStatementGroup* tmp = new SgDataStatementGroup ( *storageArray ) ;
31595 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31596 0 : storageArray++ ;
31597 : }
31598 : }
31599 0 : delete [] storageArraySgDataStatementGroup;
31600 2 : SgDataStatementGroupStorageClass :: deleteStaticDataOfEasyStorageClasses();
31601 :
31602 :
31603 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDataStatementObject );
31604 2 : SgDataStatementObjectStorageClass* storageArraySgDataStatementObject = NULL;
31605 2 : if ( 0 < sizeOfActualPool )
31606 : {
31607 0 : storageArraySgDataStatementObject = new SgDataStatementObjectStorageClass[sizeOfActualPool] ;
31608 0 : inFile.read ( (char*) (storageArraySgDataStatementObject) , sizeof ( SgDataStatementObjectStorageClass ) * sizeOfActualPool) ;
31609 : SgDataStatementObjectStorageClass* storageArray = storageArraySgDataStatementObject;
31610 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31611 : {
31612 0 : SgDataStatementObject* tmp = new SgDataStatementObject ( *storageArray ) ;
31613 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31614 0 : storageArray++ ;
31615 : }
31616 : }
31617 0 : delete [] storageArraySgDataStatementObject;
31618 :
31619 :
31620 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDataStatementValue );
31621 2 : SgDataStatementValueStorageClass* storageArraySgDataStatementValue = NULL;
31622 2 : if ( 0 < sizeOfActualPool )
31623 : {
31624 0 : storageArraySgDataStatementValue = new SgDataStatementValueStorageClass[sizeOfActualPool] ;
31625 0 : inFile.read ( (char*) (storageArraySgDataStatementValue) , sizeof ( SgDataStatementValueStorageClass ) * sizeOfActualPool) ;
31626 : SgDataStatementValueStorageClass* storageArray = storageArraySgDataStatementValue;
31627 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31628 : {
31629 0 : SgDataStatementValue* tmp = new SgDataStatementValue ( *storageArray ) ;
31630 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31631 0 : storageArray++ ;
31632 : }
31633 : }
31634 0 : delete [] storageArraySgDataStatementValue;
31635 :
31636 :
31637 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeadIfDirectiveStatement );
31638 2 : SgDeadIfDirectiveStatementStorageClass* storageArraySgDeadIfDirectiveStatement = NULL;
31639 2 : if ( 0 < sizeOfActualPool )
31640 : {
31641 0 : storageArraySgDeadIfDirectiveStatement = new SgDeadIfDirectiveStatementStorageClass[sizeOfActualPool] ;
31642 0 : inFile.read ( (char*) (storageArraySgDeadIfDirectiveStatement) , sizeof ( SgDeadIfDirectiveStatementStorageClass ) * sizeOfActualPool) ;
31643 0 : SgDeadIfDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31644 : SgDeadIfDirectiveStatementStorageClass* storageArray = storageArraySgDeadIfDirectiveStatement;
31645 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31646 : {
31647 0 : SgDeadIfDirectiveStatement* tmp = new SgDeadIfDirectiveStatement ( *storageArray ) ;
31648 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31649 0 : storageArray++ ;
31650 : }
31651 : }
31652 0 : delete [] storageArraySgDeadIfDirectiveStatement;
31653 2 : SgDeadIfDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31654 :
31655 :
31656 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeallocateStatement );
31657 2 : SgDeallocateStatementStorageClass* storageArraySgDeallocateStatement = NULL;
31658 2 : if ( 0 < sizeOfActualPool )
31659 : {
31660 0 : storageArraySgDeallocateStatement = new SgDeallocateStatementStorageClass[sizeOfActualPool] ;
31661 0 : inFile.read ( (char*) (storageArraySgDeallocateStatement) , sizeof ( SgDeallocateStatementStorageClass ) * sizeOfActualPool) ;
31662 0 : SgDeallocateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31663 : SgDeallocateStatementStorageClass* storageArray = storageArraySgDeallocateStatement;
31664 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31665 : {
31666 0 : SgDeallocateStatement* tmp = new SgDeallocateStatement ( *storageArray ) ;
31667 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31668 0 : storageArray++ ;
31669 : }
31670 : }
31671 0 : delete [] storageArraySgDeallocateStatement;
31672 2 : SgDeallocateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31673 :
31674 :
31675 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeclarationModifier );
31676 2 : SgDeclarationModifierStorageClass* storageArraySgDeclarationModifier = NULL;
31677 2 : if ( 0 < sizeOfActualPool )
31678 : {
31679 0 : storageArraySgDeclarationModifier = new SgDeclarationModifierStorageClass[sizeOfActualPool] ;
31680 0 : inFile.read ( (char*) (storageArraySgDeclarationModifier) , sizeof ( SgDeclarationModifierStorageClass ) * sizeOfActualPool) ;
31681 0 : SgDeclarationModifierStorageClass :: readEasyStorageDataFromFile(inFile) ;
31682 : SgDeclarationModifierStorageClass* storageArray = storageArraySgDeclarationModifier;
31683 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31684 : {
31685 0 : SgDeclarationModifier* tmp = new SgDeclarationModifier ( *storageArray ) ;
31686 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31687 0 : storageArray++ ;
31688 : }
31689 : }
31690 0 : delete [] storageArraySgDeclarationModifier;
31691 2 : SgDeclarationModifierStorageClass :: deleteStaticDataOfEasyStorageClasses();
31692 :
31693 :
31694 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeclarationScope );
31695 2 : SgDeclarationScopeStorageClass* storageArraySgDeclarationScope = NULL;
31696 2 : if ( 0 < sizeOfActualPool )
31697 : {
31698 6497 : storageArraySgDeclarationScope = new SgDeclarationScopeStorageClass[sizeOfActualPool] ;
31699 1 : inFile.read ( (char*) (storageArraySgDeclarationScope) , sizeof ( SgDeclarationScopeStorageClass ) * sizeOfActualPool) ;
31700 1 : SgDeclarationScopeStorageClass :: readEasyStorageDataFromFile(inFile) ;
31701 : SgDeclarationScopeStorageClass* storageArray = storageArraySgDeclarationScope;
31702 6497 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31703 : {
31704 6496 : SgDeclarationScope* tmp = new SgDeclarationScope ( *storageArray ) ;
31705 6496 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31706 6496 : storageArray++ ;
31707 : }
31708 : }
31709 1 : delete [] storageArraySgDeclarationScope;
31710 2 : SgDeclarationScopeStorageClass :: deleteStaticDataOfEasyStorageClasses();
31711 :
31712 :
31713 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeclarationStatement );
31714 2 : SgDeclarationStatementStorageClass* storageArraySgDeclarationStatement = NULL;
31715 2 : if ( 0 < sizeOfActualPool )
31716 : {
31717 0 : storageArraySgDeclarationStatement = new SgDeclarationStatementStorageClass[sizeOfActualPool] ;
31718 0 : inFile.read ( (char*) (storageArraySgDeclarationStatement) , sizeof ( SgDeclarationStatementStorageClass ) * sizeOfActualPool) ;
31719 0 : SgDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31720 : SgDeclarationStatementStorageClass* storageArray = storageArraySgDeclarationStatement;
31721 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31722 : {
31723 0 : SgDeclarationStatement* tmp = new SgDeclarationStatement ( *storageArray ) ;
31724 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31725 0 : storageArray++ ;
31726 : }
31727 : }
31728 0 : delete [] storageArraySgDeclarationStatement;
31729 2 : SgDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31730 :
31731 :
31732 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeclType );
31733 2 : SgDeclTypeStorageClass* storageArraySgDeclType = NULL;
31734 2 : if ( 0 < sizeOfActualPool )
31735 : {
31736 93 : storageArraySgDeclType = new SgDeclTypeStorageClass[sizeOfActualPool] ;
31737 1 : inFile.read ( (char*) (storageArraySgDeclType) , sizeof ( SgDeclTypeStorageClass ) * sizeOfActualPool) ;
31738 1 : SgDeclTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
31739 : SgDeclTypeStorageClass* storageArray = storageArraySgDeclType;
31740 93 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31741 : {
31742 92 : SgDeclType* tmp = new SgDeclType ( *storageArray ) ;
31743 92 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31744 92 : storageArray++ ;
31745 : }
31746 : }
31747 1 : delete [] storageArraySgDeclType;
31748 2 : SgDeclTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
31749 :
31750 :
31751 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDefaultOptionStmt );
31752 2 : SgDefaultOptionStmtStorageClass* storageArraySgDefaultOptionStmt = NULL;
31753 2 : if ( 0 < sizeOfActualPool )
31754 : {
31755 0 : storageArraySgDefaultOptionStmt = new SgDefaultOptionStmtStorageClass[sizeOfActualPool] ;
31756 0 : inFile.read ( (char*) (storageArraySgDefaultOptionStmt) , sizeof ( SgDefaultOptionStmtStorageClass ) * sizeOfActualPool) ;
31757 0 : SgDefaultOptionStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
31758 : SgDefaultOptionStmtStorageClass* storageArray = storageArraySgDefaultOptionStmt;
31759 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31760 : {
31761 0 : SgDefaultOptionStmt* tmp = new SgDefaultOptionStmt ( *storageArray ) ;
31762 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31763 0 : storageArray++ ;
31764 : }
31765 : }
31766 0 : delete [] storageArraySgDefaultOptionStmt;
31767 2 : SgDefaultOptionStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
31768 :
31769 :
31770 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDefaultSymbol );
31771 2 : SgDefaultSymbolStorageClass* storageArraySgDefaultSymbol = NULL;
31772 2 : if ( 0 < sizeOfActualPool )
31773 : {
31774 0 : storageArraySgDefaultSymbol = new SgDefaultSymbolStorageClass[sizeOfActualPool] ;
31775 0 : inFile.read ( (char*) (storageArraySgDefaultSymbol) , sizeof ( SgDefaultSymbolStorageClass ) * sizeOfActualPool) ;
31776 0 : SgDefaultSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
31777 : SgDefaultSymbolStorageClass* storageArray = storageArraySgDefaultSymbol;
31778 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31779 : {
31780 0 : SgDefaultSymbol* tmp = new SgDefaultSymbol ( *storageArray ) ;
31781 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31782 0 : storageArray++ ;
31783 : }
31784 : }
31785 0 : delete [] storageArraySgDefaultSymbol;
31786 2 : SgDefaultSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
31787 :
31788 :
31789 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDefineDirectiveStatement );
31790 2 : SgDefineDirectiveStatementStorageClass* storageArraySgDefineDirectiveStatement = NULL;
31791 2 : if ( 0 < sizeOfActualPool )
31792 : {
31793 0 : storageArraySgDefineDirectiveStatement = new SgDefineDirectiveStatementStorageClass[sizeOfActualPool] ;
31794 0 : inFile.read ( (char*) (storageArraySgDefineDirectiveStatement) , sizeof ( SgDefineDirectiveStatementStorageClass ) * sizeOfActualPool) ;
31795 0 : SgDefineDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31796 : SgDefineDirectiveStatementStorageClass* storageArray = storageArraySgDefineDirectiveStatement;
31797 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31798 : {
31799 0 : SgDefineDirectiveStatement* tmp = new SgDefineDirectiveStatement ( *storageArray ) ;
31800 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31801 0 : storageArray++ ;
31802 : }
31803 : }
31804 0 : delete [] storageArraySgDefineDirectiveStatement;
31805 2 : SgDefineDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31806 :
31807 :
31808 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDeleteExp );
31809 2 : SgDeleteExpStorageClass* storageArraySgDeleteExp = NULL;
31810 2 : if ( 0 < sizeOfActualPool )
31811 : {
31812 16 : storageArraySgDeleteExp = new SgDeleteExpStorageClass[sizeOfActualPool] ;
31813 1 : inFile.read ( (char*) (storageArraySgDeleteExp) , sizeof ( SgDeleteExpStorageClass ) * sizeOfActualPool) ;
31814 1 : SgDeleteExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31815 : SgDeleteExpStorageClass* storageArray = storageArraySgDeleteExp;
31816 16 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31817 : {
31818 15 : SgDeleteExp* tmp = new SgDeleteExp ( *storageArray ) ;
31819 15 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31820 15 : storageArray++ ;
31821 : }
31822 : }
31823 1 : delete [] storageArraySgDeleteExp;
31824 2 : SgDeleteExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31825 :
31826 :
31827 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDerivedTypeStatement );
31828 2 : SgDerivedTypeStatementStorageClass* storageArraySgDerivedTypeStatement = NULL;
31829 2 : if ( 0 < sizeOfActualPool )
31830 : {
31831 0 : storageArraySgDerivedTypeStatement = new SgDerivedTypeStatementStorageClass[sizeOfActualPool] ;
31832 0 : inFile.read ( (char*) (storageArraySgDerivedTypeStatement) , sizeof ( SgDerivedTypeStatementStorageClass ) * sizeOfActualPool) ;
31833 0 : SgDerivedTypeStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
31834 : SgDerivedTypeStatementStorageClass* storageArray = storageArraySgDerivedTypeStatement;
31835 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31836 : {
31837 0 : SgDerivedTypeStatement* tmp = new SgDerivedTypeStatement ( *storageArray ) ;
31838 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31839 0 : storageArray++ ;
31840 : }
31841 : }
31842 0 : delete [] storageArraySgDerivedTypeStatement;
31843 2 : SgDerivedTypeStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
31844 :
31845 :
31846 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDesignatedInitializer );
31847 2 : SgDesignatedInitializerStorageClass* storageArraySgDesignatedInitializer = NULL;
31848 2 : if ( 0 < sizeOfActualPool )
31849 : {
31850 0 : storageArraySgDesignatedInitializer = new SgDesignatedInitializerStorageClass[sizeOfActualPool] ;
31851 0 : inFile.read ( (char*) (storageArraySgDesignatedInitializer) , sizeof ( SgDesignatedInitializerStorageClass ) * sizeOfActualPool) ;
31852 0 : SgDesignatedInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
31853 : SgDesignatedInitializerStorageClass* storageArray = storageArraySgDesignatedInitializer;
31854 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31855 : {
31856 0 : SgDesignatedInitializer* tmp = new SgDesignatedInitializer ( *storageArray ) ;
31857 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31858 0 : storageArray++ ;
31859 : }
31860 : }
31861 0 : delete [] storageArraySgDesignatedInitializer;
31862 2 : SgDesignatedInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
31863 :
31864 :
31865 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDictionaryComprehension );
31866 2 : SgDictionaryComprehensionStorageClass* storageArraySgDictionaryComprehension = NULL;
31867 2 : if ( 0 < sizeOfActualPool )
31868 : {
31869 0 : storageArraySgDictionaryComprehension = new SgDictionaryComprehensionStorageClass[sizeOfActualPool] ;
31870 0 : inFile.read ( (char*) (storageArraySgDictionaryComprehension) , sizeof ( SgDictionaryComprehensionStorageClass ) * sizeOfActualPool) ;
31871 0 : SgDictionaryComprehensionStorageClass :: readEasyStorageDataFromFile(inFile) ;
31872 : SgDictionaryComprehensionStorageClass* storageArray = storageArraySgDictionaryComprehension;
31873 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31874 : {
31875 0 : SgDictionaryComprehension* tmp = new SgDictionaryComprehension ( *storageArray ) ;
31876 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31877 0 : storageArray++ ;
31878 : }
31879 : }
31880 0 : delete [] storageArraySgDictionaryComprehension;
31881 2 : SgDictionaryComprehensionStorageClass :: deleteStaticDataOfEasyStorageClasses();
31882 :
31883 :
31884 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDictionaryExp );
31885 2 : SgDictionaryExpStorageClass* storageArraySgDictionaryExp = NULL;
31886 2 : if ( 0 < sizeOfActualPool )
31887 : {
31888 0 : storageArraySgDictionaryExp = new SgDictionaryExpStorageClass[sizeOfActualPool] ;
31889 0 : inFile.read ( (char*) (storageArraySgDictionaryExp) , sizeof ( SgDictionaryExpStorageClass ) * sizeOfActualPool) ;
31890 0 : SgDictionaryExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31891 : SgDictionaryExpStorageClass* storageArray = storageArraySgDictionaryExp;
31892 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31893 : {
31894 0 : SgDictionaryExp* tmp = new SgDictionaryExp ( *storageArray ) ;
31895 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31896 0 : storageArray++ ;
31897 : }
31898 : }
31899 0 : delete [] storageArraySgDictionaryExp;
31900 2 : SgDictionaryExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31901 :
31902 :
31903 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDimensionObject );
31904 2 : SgDimensionObjectStorageClass* storageArraySgDimensionObject = NULL;
31905 2 : if ( 0 < sizeOfActualPool )
31906 : {
31907 0 : storageArraySgDimensionObject = new SgDimensionObjectStorageClass[sizeOfActualPool] ;
31908 0 : inFile.read ( (char*) (storageArraySgDimensionObject) , sizeof ( SgDimensionObjectStorageClass ) * sizeOfActualPool) ;
31909 : SgDimensionObjectStorageClass* storageArray = storageArraySgDimensionObject;
31910 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31911 : {
31912 0 : SgDimensionObject* tmp = new SgDimensionObject ( *storageArray ) ;
31913 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31914 0 : storageArray++ ;
31915 : }
31916 : }
31917 0 : delete [] storageArraySgDimensionObject;
31918 :
31919 :
31920 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDirectedGraphEdge );
31921 2 : SgDirectedGraphEdgeStorageClass* storageArraySgDirectedGraphEdge = NULL;
31922 2 : if ( 0 < sizeOfActualPool )
31923 : {
31924 0 : storageArraySgDirectedGraphEdge = new SgDirectedGraphEdgeStorageClass[sizeOfActualPool] ;
31925 0 : inFile.read ( (char*) (storageArraySgDirectedGraphEdge) , sizeof ( SgDirectedGraphEdgeStorageClass ) * sizeOfActualPool) ;
31926 0 : SgDirectedGraphEdgeStorageClass :: readEasyStorageDataFromFile(inFile) ;
31927 : SgDirectedGraphEdgeStorageClass* storageArray = storageArraySgDirectedGraphEdge;
31928 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31929 : {
31930 0 : SgDirectedGraphEdge* tmp = new SgDirectedGraphEdge ( *storageArray ) ;
31931 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31932 0 : storageArray++ ;
31933 : }
31934 : }
31935 0 : delete [] storageArraySgDirectedGraphEdge;
31936 2 : SgDirectedGraphEdgeStorageClass :: deleteStaticDataOfEasyStorageClasses();
31937 :
31938 :
31939 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDirectory );
31940 2 : SgDirectoryStorageClass* storageArraySgDirectory = NULL;
31941 2 : if ( 0 < sizeOfActualPool )
31942 : {
31943 0 : storageArraySgDirectory = new SgDirectoryStorageClass[sizeOfActualPool] ;
31944 0 : inFile.read ( (char*) (storageArraySgDirectory) , sizeof ( SgDirectoryStorageClass ) * sizeOfActualPool) ;
31945 0 : SgDirectoryStorageClass :: readEasyStorageDataFromFile(inFile) ;
31946 : SgDirectoryStorageClass* storageArray = storageArraySgDirectory;
31947 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31948 : {
31949 0 : SgDirectory* tmp = new SgDirectory ( *storageArray ) ;
31950 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31951 0 : storageArray++ ;
31952 : }
31953 : }
31954 0 : delete [] storageArraySgDirectory;
31955 2 : SgDirectoryStorageClass :: deleteStaticDataOfEasyStorageClasses();
31956 :
31957 :
31958 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDirectoryList );
31959 2 : SgDirectoryListStorageClass* storageArraySgDirectoryList = NULL;
31960 2 : if ( 0 < sizeOfActualPool )
31961 : {
31962 4 : storageArraySgDirectoryList = new SgDirectoryListStorageClass[sizeOfActualPool] ;
31963 2 : inFile.read ( (char*) (storageArraySgDirectoryList) , sizeof ( SgDirectoryListStorageClass ) * sizeOfActualPool) ;
31964 2 : SgDirectoryListStorageClass :: readEasyStorageDataFromFile(inFile) ;
31965 : SgDirectoryListStorageClass* storageArray = storageArraySgDirectoryList;
31966 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31967 : {
31968 2 : SgDirectoryList* tmp = new SgDirectoryList ( *storageArray ) ;
31969 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31970 2 : storageArray++ ;
31971 : }
31972 : }
31973 2 : delete [] storageArraySgDirectoryList;
31974 2 : SgDirectoryListStorageClass :: deleteStaticDataOfEasyStorageClasses();
31975 :
31976 :
31977 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDivAssignOp );
31978 2 : SgDivAssignOpStorageClass* storageArraySgDivAssignOp = NULL;
31979 2 : if ( 0 < sizeOfActualPool )
31980 : {
31981 2 : storageArraySgDivAssignOp = new SgDivAssignOpStorageClass[sizeOfActualPool] ;
31982 1 : inFile.read ( (char*) (storageArraySgDivAssignOp) , sizeof ( SgDivAssignOpStorageClass ) * sizeOfActualPool) ;
31983 1 : SgDivAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
31984 : SgDivAssignOpStorageClass* storageArray = storageArraySgDivAssignOp;
31985 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
31986 : {
31987 1 : SgDivAssignOp* tmp = new SgDivAssignOp ( *storageArray ) ;
31988 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
31989 1 : storageArray++ ;
31990 : }
31991 : }
31992 1 : delete [] storageArraySgDivAssignOp;
31993 2 : SgDivAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
31994 :
31995 :
31996 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDivideOp );
31997 2 : SgDivideOpStorageClass* storageArraySgDivideOp = NULL;
31998 2 : if ( 0 < sizeOfActualPool )
31999 : {
32000 38 : storageArraySgDivideOp = new SgDivideOpStorageClass[sizeOfActualPool] ;
32001 1 : inFile.read ( (char*) (storageArraySgDivideOp) , sizeof ( SgDivideOpStorageClass ) * sizeOfActualPool) ;
32002 1 : SgDivideOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32003 : SgDivideOpStorageClass* storageArray = storageArraySgDivideOp;
32004 38 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32005 : {
32006 37 : SgDivideOp* tmp = new SgDivideOp ( *storageArray ) ;
32007 37 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32008 37 : storageArray++ ;
32009 : }
32010 : }
32011 1 : delete [] storageArraySgDivideOp;
32012 2 : SgDivideOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32013 :
32014 :
32015 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDoWhileStmt );
32016 2 : SgDoWhileStmtStorageClass* storageArraySgDoWhileStmt = NULL;
32017 2 : if ( 0 < sizeOfActualPool )
32018 : {
32019 8 : storageArraySgDoWhileStmt = new SgDoWhileStmtStorageClass[sizeOfActualPool] ;
32020 1 : inFile.read ( (char*) (storageArraySgDoWhileStmt) , sizeof ( SgDoWhileStmtStorageClass ) * sizeOfActualPool) ;
32021 1 : SgDoWhileStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
32022 : SgDoWhileStmtStorageClass* storageArray = storageArraySgDoWhileStmt;
32023 8 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32024 : {
32025 7 : SgDoWhileStmt* tmp = new SgDoWhileStmt ( *storageArray ) ;
32026 7 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32027 7 : storageArray++ ;
32028 : }
32029 : }
32030 1 : delete [] storageArraySgDoWhileStmt;
32031 2 : SgDoWhileStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
32032 :
32033 :
32034 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDotExp );
32035 2 : SgDotExpStorageClass* storageArraySgDotExp = NULL;
32036 2 : if ( 0 < sizeOfActualPool )
32037 : {
32038 817 : storageArraySgDotExp = new SgDotExpStorageClass[sizeOfActualPool] ;
32039 1 : inFile.read ( (char*) (storageArraySgDotExp) , sizeof ( SgDotExpStorageClass ) * sizeOfActualPool) ;
32040 1 : SgDotExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32041 : SgDotExpStorageClass* storageArray = storageArraySgDotExp;
32042 817 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32043 : {
32044 816 : SgDotExp* tmp = new SgDotExp ( *storageArray ) ;
32045 816 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32046 816 : storageArray++ ;
32047 : }
32048 : }
32049 1 : delete [] storageArraySgDotExp;
32050 2 : SgDotExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32051 :
32052 :
32053 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDotStarOp );
32054 2 : SgDotStarOpStorageClass* storageArraySgDotStarOp = NULL;
32055 2 : if ( 0 < sizeOfActualPool )
32056 : {
32057 13 : storageArraySgDotStarOp = new SgDotStarOpStorageClass[sizeOfActualPool] ;
32058 1 : inFile.read ( (char*) (storageArraySgDotStarOp) , sizeof ( SgDotStarOpStorageClass ) * sizeOfActualPool) ;
32059 1 : SgDotStarOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32060 : SgDotStarOpStorageClass* storageArray = storageArraySgDotStarOp;
32061 13 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32062 : {
32063 12 : SgDotStarOp* tmp = new SgDotStarOp ( *storageArray ) ;
32064 12 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32065 12 : storageArray++ ;
32066 : }
32067 : }
32068 1 : delete [] storageArraySgDotStarOp;
32069 2 : SgDotStarOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32070 :
32071 :
32072 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgDoubleVal );
32073 2 : SgDoubleValStorageClass* storageArraySgDoubleVal = NULL;
32074 2 : if ( 0 < sizeOfActualPool )
32075 : {
32076 2 : storageArraySgDoubleVal = new SgDoubleValStorageClass[sizeOfActualPool] ;
32077 1 : inFile.read ( (char*) (storageArraySgDoubleVal) , sizeof ( SgDoubleValStorageClass ) * sizeOfActualPool) ;
32078 1 : SgDoubleValStorageClass :: readEasyStorageDataFromFile(inFile) ;
32079 : SgDoubleValStorageClass* storageArray = storageArraySgDoubleVal;
32080 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32081 : {
32082 1 : SgDoubleVal* tmp = new SgDoubleVal ( *storageArray ) ;
32083 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32084 1 : storageArray++ ;
32085 : }
32086 : }
32087 1 : delete [] storageArraySgDoubleVal;
32088 2 : SgDoubleValStorageClass :: deleteStaticDataOfEasyStorageClasses();
32089 :
32090 :
32091 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElaboratedTypeModifier );
32092 2 : SgElaboratedTypeModifierStorageClass* storageArraySgElaboratedTypeModifier = NULL;
32093 2 : if ( 0 < sizeOfActualPool )
32094 : {
32095 0 : storageArraySgElaboratedTypeModifier = new SgElaboratedTypeModifierStorageClass[sizeOfActualPool] ;
32096 0 : inFile.read ( (char*) (storageArraySgElaboratedTypeModifier) , sizeof ( SgElaboratedTypeModifierStorageClass ) * sizeOfActualPool) ;
32097 : SgElaboratedTypeModifierStorageClass* storageArray = storageArraySgElaboratedTypeModifier;
32098 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32099 : {
32100 0 : SgElaboratedTypeModifier* tmp = new SgElaboratedTypeModifier ( *storageArray ) ;
32101 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32102 0 : storageArray++ ;
32103 : }
32104 : }
32105 0 : delete [] storageArraySgElaboratedTypeModifier;
32106 :
32107 :
32108 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseOp );
32109 2 : SgElementwiseOpStorageClass* storageArraySgElementwiseOp = NULL;
32110 2 : if ( 0 < sizeOfActualPool )
32111 : {
32112 0 : storageArraySgElementwiseOp = new SgElementwiseOpStorageClass[sizeOfActualPool] ;
32113 0 : inFile.read ( (char*) (storageArraySgElementwiseOp) , sizeof ( SgElementwiseOpStorageClass ) * sizeOfActualPool) ;
32114 0 : SgElementwiseOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32115 : SgElementwiseOpStorageClass* storageArray = storageArraySgElementwiseOp;
32116 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32117 : {
32118 0 : SgElementwiseOp* tmp = new SgElementwiseOp ( *storageArray ) ;
32119 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32120 0 : storageArray++ ;
32121 : }
32122 : }
32123 0 : delete [] storageArraySgElementwiseOp;
32124 2 : SgElementwiseOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32125 :
32126 :
32127 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseAddOp );
32128 2 : SgElementwiseAddOpStorageClass* storageArraySgElementwiseAddOp = NULL;
32129 2 : if ( 0 < sizeOfActualPool )
32130 : {
32131 0 : storageArraySgElementwiseAddOp = new SgElementwiseAddOpStorageClass[sizeOfActualPool] ;
32132 0 : inFile.read ( (char*) (storageArraySgElementwiseAddOp) , sizeof ( SgElementwiseAddOpStorageClass ) * sizeOfActualPool) ;
32133 0 : SgElementwiseAddOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32134 : SgElementwiseAddOpStorageClass* storageArray = storageArraySgElementwiseAddOp;
32135 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32136 : {
32137 0 : SgElementwiseAddOp* tmp = new SgElementwiseAddOp ( *storageArray ) ;
32138 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32139 0 : storageArray++ ;
32140 : }
32141 : }
32142 0 : delete [] storageArraySgElementwiseAddOp;
32143 2 : SgElementwiseAddOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32144 :
32145 :
32146 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseDivideOp );
32147 2 : SgElementwiseDivideOpStorageClass* storageArraySgElementwiseDivideOp = NULL;
32148 2 : if ( 0 < sizeOfActualPool )
32149 : {
32150 0 : storageArraySgElementwiseDivideOp = new SgElementwiseDivideOpStorageClass[sizeOfActualPool] ;
32151 0 : inFile.read ( (char*) (storageArraySgElementwiseDivideOp) , sizeof ( SgElementwiseDivideOpStorageClass ) * sizeOfActualPool) ;
32152 0 : SgElementwiseDivideOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32153 : SgElementwiseDivideOpStorageClass* storageArray = storageArraySgElementwiseDivideOp;
32154 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32155 : {
32156 0 : SgElementwiseDivideOp* tmp = new SgElementwiseDivideOp ( *storageArray ) ;
32157 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32158 0 : storageArray++ ;
32159 : }
32160 : }
32161 0 : delete [] storageArraySgElementwiseDivideOp;
32162 2 : SgElementwiseDivideOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32163 :
32164 :
32165 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseLeftDivideOp );
32166 2 : SgElementwiseLeftDivideOpStorageClass* storageArraySgElementwiseLeftDivideOp = NULL;
32167 2 : if ( 0 < sizeOfActualPool )
32168 : {
32169 0 : storageArraySgElementwiseLeftDivideOp = new SgElementwiseLeftDivideOpStorageClass[sizeOfActualPool] ;
32170 0 : inFile.read ( (char*) (storageArraySgElementwiseLeftDivideOp) , sizeof ( SgElementwiseLeftDivideOpStorageClass ) * sizeOfActualPool) ;
32171 0 : SgElementwiseLeftDivideOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32172 : SgElementwiseLeftDivideOpStorageClass* storageArray = storageArraySgElementwiseLeftDivideOp;
32173 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32174 : {
32175 0 : SgElementwiseLeftDivideOp* tmp = new SgElementwiseLeftDivideOp ( *storageArray ) ;
32176 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32177 0 : storageArray++ ;
32178 : }
32179 : }
32180 0 : delete [] storageArraySgElementwiseLeftDivideOp;
32181 2 : SgElementwiseLeftDivideOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32182 :
32183 :
32184 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseMultiplyOp );
32185 2 : SgElementwiseMultiplyOpStorageClass* storageArraySgElementwiseMultiplyOp = NULL;
32186 2 : if ( 0 < sizeOfActualPool )
32187 : {
32188 0 : storageArraySgElementwiseMultiplyOp = new SgElementwiseMultiplyOpStorageClass[sizeOfActualPool] ;
32189 0 : inFile.read ( (char*) (storageArraySgElementwiseMultiplyOp) , sizeof ( SgElementwiseMultiplyOpStorageClass ) * sizeOfActualPool) ;
32190 0 : SgElementwiseMultiplyOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32191 : SgElementwiseMultiplyOpStorageClass* storageArray = storageArraySgElementwiseMultiplyOp;
32192 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32193 : {
32194 0 : SgElementwiseMultiplyOp* tmp = new SgElementwiseMultiplyOp ( *storageArray ) ;
32195 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32196 0 : storageArray++ ;
32197 : }
32198 : }
32199 0 : delete [] storageArraySgElementwiseMultiplyOp;
32200 2 : SgElementwiseMultiplyOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32201 :
32202 :
32203 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwisePowerOp );
32204 2 : SgElementwisePowerOpStorageClass* storageArraySgElementwisePowerOp = NULL;
32205 2 : if ( 0 < sizeOfActualPool )
32206 : {
32207 0 : storageArraySgElementwisePowerOp = new SgElementwisePowerOpStorageClass[sizeOfActualPool] ;
32208 0 : inFile.read ( (char*) (storageArraySgElementwisePowerOp) , sizeof ( SgElementwisePowerOpStorageClass ) * sizeOfActualPool) ;
32209 0 : SgElementwisePowerOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32210 : SgElementwisePowerOpStorageClass* storageArray = storageArraySgElementwisePowerOp;
32211 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32212 : {
32213 0 : SgElementwisePowerOp* tmp = new SgElementwisePowerOp ( *storageArray ) ;
32214 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32215 0 : storageArray++ ;
32216 : }
32217 : }
32218 0 : delete [] storageArraySgElementwisePowerOp;
32219 2 : SgElementwisePowerOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32220 :
32221 :
32222 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElementwiseSubtractOp );
32223 2 : SgElementwiseSubtractOpStorageClass* storageArraySgElementwiseSubtractOp = NULL;
32224 2 : if ( 0 < sizeOfActualPool )
32225 : {
32226 0 : storageArraySgElementwiseSubtractOp = new SgElementwiseSubtractOpStorageClass[sizeOfActualPool] ;
32227 0 : inFile.read ( (char*) (storageArraySgElementwiseSubtractOp) , sizeof ( SgElementwiseSubtractOpStorageClass ) * sizeOfActualPool) ;
32228 0 : SgElementwiseSubtractOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32229 : SgElementwiseSubtractOpStorageClass* storageArray = storageArraySgElementwiseSubtractOp;
32230 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32231 : {
32232 0 : SgElementwiseSubtractOp* tmp = new SgElementwiseSubtractOp ( *storageArray ) ;
32233 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32234 0 : storageArray++ ;
32235 : }
32236 : }
32237 0 : delete [] storageArraySgElementwiseSubtractOp;
32238 2 : SgElementwiseSubtractOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32239 :
32240 :
32241 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElseDirectiveStatement );
32242 2 : SgElseDirectiveStatementStorageClass* storageArraySgElseDirectiveStatement = NULL;
32243 2 : if ( 0 < sizeOfActualPool )
32244 : {
32245 0 : storageArraySgElseDirectiveStatement = new SgElseDirectiveStatementStorageClass[sizeOfActualPool] ;
32246 0 : inFile.read ( (char*) (storageArraySgElseDirectiveStatement) , sizeof ( SgElseDirectiveStatementStorageClass ) * sizeOfActualPool) ;
32247 0 : SgElseDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32248 : SgElseDirectiveStatementStorageClass* storageArray = storageArraySgElseDirectiveStatement;
32249 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32250 : {
32251 0 : SgElseDirectiveStatement* tmp = new SgElseDirectiveStatement ( *storageArray ) ;
32252 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32253 0 : storageArray++ ;
32254 : }
32255 : }
32256 0 : delete [] storageArraySgElseDirectiveStatement;
32257 2 : SgElseDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32258 :
32259 :
32260 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElseWhereStatement );
32261 2 : SgElseWhereStatementStorageClass* storageArraySgElseWhereStatement = NULL;
32262 2 : if ( 0 < sizeOfActualPool )
32263 : {
32264 0 : storageArraySgElseWhereStatement = new SgElseWhereStatementStorageClass[sizeOfActualPool] ;
32265 0 : inFile.read ( (char*) (storageArraySgElseWhereStatement) , sizeof ( SgElseWhereStatementStorageClass ) * sizeOfActualPool) ;
32266 0 : SgElseWhereStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32267 : SgElseWhereStatementStorageClass* storageArray = storageArraySgElseWhereStatement;
32268 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32269 : {
32270 0 : SgElseWhereStatement* tmp = new SgElseWhereStatement ( *storageArray ) ;
32271 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32272 0 : storageArray++ ;
32273 : }
32274 : }
32275 0 : delete [] storageArraySgElseWhereStatement;
32276 2 : SgElseWhereStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32277 :
32278 :
32279 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgElseifDirectiveStatement );
32280 2 : SgElseifDirectiveStatementStorageClass* storageArraySgElseifDirectiveStatement = NULL;
32281 2 : if ( 0 < sizeOfActualPool )
32282 : {
32283 0 : storageArraySgElseifDirectiveStatement = new SgElseifDirectiveStatementStorageClass[sizeOfActualPool] ;
32284 0 : inFile.read ( (char*) (storageArraySgElseifDirectiveStatement) , sizeof ( SgElseifDirectiveStatementStorageClass ) * sizeOfActualPool) ;
32285 0 : SgElseifDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32286 : SgElseifDirectiveStatementStorageClass* storageArray = storageArraySgElseifDirectiveStatement;
32287 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32288 : {
32289 0 : SgElseifDirectiveStatement* tmp = new SgElseifDirectiveStatement ( *storageArray ) ;
32290 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32291 0 : storageArray++ ;
32292 : }
32293 : }
32294 0 : delete [] storageArraySgElseifDirectiveStatement;
32295 2 : SgElseifDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32296 :
32297 :
32298 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEmptyDeclaration );
32299 2 : SgEmptyDeclarationStorageClass* storageArraySgEmptyDeclaration = NULL;
32300 2 : if ( 0 < sizeOfActualPool )
32301 : {
32302 0 : storageArraySgEmptyDeclaration = new SgEmptyDeclarationStorageClass[sizeOfActualPool] ;
32303 0 : inFile.read ( (char*) (storageArraySgEmptyDeclaration) , sizeof ( SgEmptyDeclarationStorageClass ) * sizeOfActualPool) ;
32304 0 : SgEmptyDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
32305 : SgEmptyDeclarationStorageClass* storageArray = storageArraySgEmptyDeclaration;
32306 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32307 : {
32308 0 : SgEmptyDeclaration* tmp = new SgEmptyDeclaration ( *storageArray ) ;
32309 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32310 0 : storageArray++ ;
32311 : }
32312 : }
32313 0 : delete [] storageArraySgEmptyDeclaration;
32314 2 : SgEmptyDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
32315 :
32316 :
32317 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEmptyDirectiveStatement );
32318 2 : SgEmptyDirectiveStatementStorageClass* storageArraySgEmptyDirectiveStatement = NULL;
32319 2 : if ( 0 < sizeOfActualPool )
32320 : {
32321 0 : storageArraySgEmptyDirectiveStatement = new SgEmptyDirectiveStatementStorageClass[sizeOfActualPool] ;
32322 0 : inFile.read ( (char*) (storageArraySgEmptyDirectiveStatement) , sizeof ( SgEmptyDirectiveStatementStorageClass ) * sizeOfActualPool) ;
32323 0 : SgEmptyDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32324 : SgEmptyDirectiveStatementStorageClass* storageArray = storageArraySgEmptyDirectiveStatement;
32325 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32326 : {
32327 0 : SgEmptyDirectiveStatement* tmp = new SgEmptyDirectiveStatement ( *storageArray ) ;
32328 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32329 0 : storageArray++ ;
32330 : }
32331 : }
32332 0 : delete [] storageArraySgEmptyDirectiveStatement;
32333 2 : SgEmptyDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32334 :
32335 :
32336 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEndfileStatement );
32337 2 : SgEndfileStatementStorageClass* storageArraySgEndfileStatement = NULL;
32338 2 : if ( 0 < sizeOfActualPool )
32339 : {
32340 0 : storageArraySgEndfileStatement = new SgEndfileStatementStorageClass[sizeOfActualPool] ;
32341 0 : inFile.read ( (char*) (storageArraySgEndfileStatement) , sizeof ( SgEndfileStatementStorageClass ) * sizeOfActualPool) ;
32342 0 : SgEndfileStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32343 : SgEndfileStatementStorageClass* storageArray = storageArraySgEndfileStatement;
32344 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32345 : {
32346 0 : SgEndfileStatement* tmp = new SgEndfileStatement ( *storageArray ) ;
32347 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32348 0 : storageArray++ ;
32349 : }
32350 : }
32351 0 : delete [] storageArraySgEndfileStatement;
32352 2 : SgEndfileStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32353 :
32354 :
32355 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEndifDirectiveStatement );
32356 2 : SgEndifDirectiveStatementStorageClass* storageArraySgEndifDirectiveStatement = NULL;
32357 2 : if ( 0 < sizeOfActualPool )
32358 : {
32359 0 : storageArraySgEndifDirectiveStatement = new SgEndifDirectiveStatementStorageClass[sizeOfActualPool] ;
32360 0 : inFile.read ( (char*) (storageArraySgEndifDirectiveStatement) , sizeof ( SgEndifDirectiveStatementStorageClass ) * sizeOfActualPool) ;
32361 0 : SgEndifDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32362 : SgEndifDirectiveStatementStorageClass* storageArray = storageArraySgEndifDirectiveStatement;
32363 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32364 : {
32365 0 : SgEndifDirectiveStatement* tmp = new SgEndifDirectiveStatement ( *storageArray ) ;
32366 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32367 0 : storageArray++ ;
32368 : }
32369 : }
32370 0 : delete [] storageArraySgEndifDirectiveStatement;
32371 2 : SgEndifDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32372 :
32373 :
32374 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEntryStatement );
32375 2 : SgEntryStatementStorageClass* storageArraySgEntryStatement = NULL;
32376 2 : if ( 0 < sizeOfActualPool )
32377 : {
32378 0 : storageArraySgEntryStatement = new SgEntryStatementStorageClass[sizeOfActualPool] ;
32379 0 : inFile.read ( (char*) (storageArraySgEntryStatement) , sizeof ( SgEntryStatementStorageClass ) * sizeOfActualPool) ;
32380 0 : SgEntryStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32381 : SgEntryStatementStorageClass* storageArray = storageArraySgEntryStatement;
32382 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32383 : {
32384 0 : SgEntryStatement* tmp = new SgEntryStatement ( *storageArray ) ;
32385 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32386 0 : storageArray++ ;
32387 : }
32388 : }
32389 0 : delete [] storageArraySgEntryStatement;
32390 2 : SgEntryStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32391 :
32392 :
32393 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEnumDeclaration );
32394 2 : SgEnumDeclarationStorageClass* storageArraySgEnumDeclaration = NULL;
32395 2 : if ( 0 < sizeOfActualPool )
32396 : {
32397 177 : storageArraySgEnumDeclaration = new SgEnumDeclarationStorageClass[sizeOfActualPool] ;
32398 1 : inFile.read ( (char*) (storageArraySgEnumDeclaration) , sizeof ( SgEnumDeclarationStorageClass ) * sizeOfActualPool) ;
32399 1 : SgEnumDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
32400 : SgEnumDeclarationStorageClass* storageArray = storageArraySgEnumDeclaration;
32401 177 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32402 : {
32403 176 : SgEnumDeclaration* tmp = new SgEnumDeclaration ( *storageArray ) ;
32404 176 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32405 176 : storageArray++ ;
32406 : }
32407 : }
32408 1 : delete [] storageArraySgEnumDeclaration;
32409 2 : SgEnumDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
32410 :
32411 :
32412 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEnumFieldSymbol );
32413 2 : SgEnumFieldSymbolStorageClass* storageArraySgEnumFieldSymbol = NULL;
32414 2 : if ( 0 < sizeOfActualPool )
32415 : {
32416 280 : storageArraySgEnumFieldSymbol = new SgEnumFieldSymbolStorageClass[sizeOfActualPool] ;
32417 1 : inFile.read ( (char*) (storageArraySgEnumFieldSymbol) , sizeof ( SgEnumFieldSymbolStorageClass ) * sizeOfActualPool) ;
32418 1 : SgEnumFieldSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
32419 : SgEnumFieldSymbolStorageClass* storageArray = storageArraySgEnumFieldSymbol;
32420 280 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32421 : {
32422 279 : SgEnumFieldSymbol* tmp = new SgEnumFieldSymbol ( *storageArray ) ;
32423 279 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32424 279 : storageArray++ ;
32425 : }
32426 : }
32427 1 : delete [] storageArraySgEnumFieldSymbol;
32428 2 : SgEnumFieldSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
32429 :
32430 :
32431 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEnumSymbol );
32432 2 : SgEnumSymbolStorageClass* storageArraySgEnumSymbol = NULL;
32433 2 : if ( 0 < sizeOfActualPool )
32434 : {
32435 89 : storageArraySgEnumSymbol = new SgEnumSymbolStorageClass[sizeOfActualPool] ;
32436 1 : inFile.read ( (char*) (storageArraySgEnumSymbol) , sizeof ( SgEnumSymbolStorageClass ) * sizeOfActualPool) ;
32437 1 : SgEnumSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
32438 : SgEnumSymbolStorageClass* storageArray = storageArraySgEnumSymbol;
32439 89 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32440 : {
32441 88 : SgEnumSymbol* tmp = new SgEnumSymbol ( *storageArray ) ;
32442 88 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32443 88 : storageArray++ ;
32444 : }
32445 : }
32446 1 : delete [] storageArraySgEnumSymbol;
32447 2 : SgEnumSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
32448 :
32449 :
32450 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEnumType );
32451 2 : SgEnumTypeStorageClass* storageArraySgEnumType = NULL;
32452 2 : if ( 0 < sizeOfActualPool )
32453 : {
32454 88 : storageArraySgEnumType = new SgEnumTypeStorageClass[sizeOfActualPool] ;
32455 1 : inFile.read ( (char*) (storageArraySgEnumType) , sizeof ( SgEnumTypeStorageClass ) * sizeOfActualPool) ;
32456 1 : SgEnumTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
32457 : SgEnumTypeStorageClass* storageArray = storageArraySgEnumType;
32458 88 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32459 : {
32460 87 : SgEnumType* tmp = new SgEnumType ( *storageArray ) ;
32461 87 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32462 87 : storageArray++ ;
32463 : }
32464 : }
32465 1 : delete [] storageArraySgEnumType;
32466 2 : SgEnumTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
32467 :
32468 :
32469 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEnumVal );
32470 2 : SgEnumValStorageClass* storageArraySgEnumVal = NULL;
32471 2 : if ( 0 < sizeOfActualPool )
32472 : {
32473 551 : storageArraySgEnumVal = new SgEnumValStorageClass[sizeOfActualPool] ;
32474 1 : inFile.read ( (char*) (storageArraySgEnumVal) , sizeof ( SgEnumValStorageClass ) * sizeOfActualPool) ;
32475 1 : SgEnumValStorageClass :: readEasyStorageDataFromFile(inFile) ;
32476 : SgEnumValStorageClass* storageArray = storageArraySgEnumVal;
32477 551 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32478 : {
32479 550 : SgEnumVal* tmp = new SgEnumVal ( *storageArray ) ;
32480 550 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32481 550 : storageArray++ ;
32482 : }
32483 : }
32484 1 : delete [] storageArraySgEnumVal;
32485 2 : SgEnumValStorageClass :: deleteStaticDataOfEasyStorageClasses();
32486 :
32487 :
32488 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEqualityOp );
32489 2 : SgEqualityOpStorageClass* storageArraySgEqualityOp = NULL;
32490 2 : if ( 0 < sizeOfActualPool )
32491 : {
32492 251 : storageArraySgEqualityOp = new SgEqualityOpStorageClass[sizeOfActualPool] ;
32493 1 : inFile.read ( (char*) (storageArraySgEqualityOp) , sizeof ( SgEqualityOpStorageClass ) * sizeOfActualPool) ;
32494 1 : SgEqualityOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32495 : SgEqualityOpStorageClass* storageArray = storageArraySgEqualityOp;
32496 251 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32497 : {
32498 250 : SgEqualityOp* tmp = new SgEqualityOp ( *storageArray ) ;
32499 250 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32500 250 : storageArray++ ;
32501 : }
32502 : }
32503 1 : delete [] storageArraySgEqualityOp;
32504 2 : SgEqualityOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32505 :
32506 :
32507 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgEquivalenceStatement );
32508 2 : SgEquivalenceStatementStorageClass* storageArraySgEquivalenceStatement = NULL;
32509 2 : if ( 0 < sizeOfActualPool )
32510 : {
32511 0 : storageArraySgEquivalenceStatement = new SgEquivalenceStatementStorageClass[sizeOfActualPool] ;
32512 0 : inFile.read ( (char*) (storageArraySgEquivalenceStatement) , sizeof ( SgEquivalenceStatementStorageClass ) * sizeOfActualPool) ;
32513 0 : SgEquivalenceStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32514 : SgEquivalenceStatementStorageClass* storageArray = storageArraySgEquivalenceStatement;
32515 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32516 : {
32517 0 : SgEquivalenceStatement* tmp = new SgEquivalenceStatement ( *storageArray ) ;
32518 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32519 0 : storageArray++ ;
32520 : }
32521 : }
32522 0 : delete [] storageArraySgEquivalenceStatement;
32523 2 : SgEquivalenceStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32524 :
32525 :
32526 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgErrorDirectiveStatement );
32527 2 : SgErrorDirectiveStatementStorageClass* storageArraySgErrorDirectiveStatement = NULL;
32528 2 : if ( 0 < sizeOfActualPool )
32529 : {
32530 0 : storageArraySgErrorDirectiveStatement = new SgErrorDirectiveStatementStorageClass[sizeOfActualPool] ;
32531 0 : inFile.read ( (char*) (storageArraySgErrorDirectiveStatement) , sizeof ( SgErrorDirectiveStatementStorageClass ) * sizeOfActualPool) ;
32532 0 : SgErrorDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32533 : SgErrorDirectiveStatementStorageClass* storageArray = storageArraySgErrorDirectiveStatement;
32534 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32535 : {
32536 0 : SgErrorDirectiveStatement* tmp = new SgErrorDirectiveStatement ( *storageArray ) ;
32537 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32538 0 : storageArray++ ;
32539 : }
32540 : }
32541 0 : delete [] storageArraySgErrorDirectiveStatement;
32542 2 : SgErrorDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32543 :
32544 :
32545 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExecStatement );
32546 2 : SgExecStatementStorageClass* storageArraySgExecStatement = NULL;
32547 2 : if ( 0 < sizeOfActualPool )
32548 : {
32549 0 : storageArraySgExecStatement = new SgExecStatementStorageClass[sizeOfActualPool] ;
32550 0 : inFile.read ( (char*) (storageArraySgExecStatement) , sizeof ( SgExecStatementStorageClass ) * sizeOfActualPool) ;
32551 0 : SgExecStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32552 : SgExecStatementStorageClass* storageArray = storageArraySgExecStatement;
32553 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32554 : {
32555 0 : SgExecStatement* tmp = new SgExecStatement ( *storageArray ) ;
32556 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32557 0 : storageArray++ ;
32558 : }
32559 : }
32560 0 : delete [] storageArraySgExecStatement;
32561 2 : SgExecStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32562 :
32563 :
32564 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExponentiationOp );
32565 2 : SgExponentiationOpStorageClass* storageArraySgExponentiationOp = NULL;
32566 2 : if ( 0 < sizeOfActualPool )
32567 : {
32568 0 : storageArraySgExponentiationOp = new SgExponentiationOpStorageClass[sizeOfActualPool] ;
32569 0 : inFile.read ( (char*) (storageArraySgExponentiationOp) , sizeof ( SgExponentiationOpStorageClass ) * sizeOfActualPool) ;
32570 0 : SgExponentiationOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32571 : SgExponentiationOpStorageClass* storageArray = storageArraySgExponentiationOp;
32572 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32573 : {
32574 0 : SgExponentiationOp* tmp = new SgExponentiationOp ( *storageArray ) ;
32575 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32576 0 : storageArray++ ;
32577 : }
32578 : }
32579 0 : delete [] storageArraySgExponentiationOp;
32580 2 : SgExponentiationOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32581 :
32582 :
32583 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExponentiationAssignOp );
32584 2 : SgExponentiationAssignOpStorageClass* storageArraySgExponentiationAssignOp = NULL;
32585 2 : if ( 0 < sizeOfActualPool )
32586 : {
32587 0 : storageArraySgExponentiationAssignOp = new SgExponentiationAssignOpStorageClass[sizeOfActualPool] ;
32588 0 : inFile.read ( (char*) (storageArraySgExponentiationAssignOp) , sizeof ( SgExponentiationAssignOpStorageClass ) * sizeOfActualPool) ;
32589 0 : SgExponentiationAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32590 : SgExponentiationAssignOpStorageClass* storageArray = storageArraySgExponentiationAssignOp;
32591 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32592 : {
32593 0 : SgExponentiationAssignOp* tmp = new SgExponentiationAssignOp ( *storageArray ) ;
32594 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32595 0 : storageArray++ ;
32596 : }
32597 : }
32598 0 : delete [] storageArraySgExponentiationAssignOp;
32599 2 : SgExponentiationAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32600 :
32601 :
32602 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExprListExp );
32603 2 : SgExprListExpStorageClass* storageArraySgExprListExp = NULL;
32604 2 : if ( 0 < sizeOfActualPool )
32605 : {
32606 3693 : storageArraySgExprListExp = new SgExprListExpStorageClass[sizeOfActualPool] ;
32607 2 : inFile.read ( (char*) (storageArraySgExprListExp) , sizeof ( SgExprListExpStorageClass ) * sizeOfActualPool) ;
32608 2 : SgExprListExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
32609 : SgExprListExpStorageClass* storageArray = storageArraySgExprListExp;
32610 3693 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32611 : {
32612 3691 : SgExprListExp* tmp = new SgExprListExp ( *storageArray ) ;
32613 3691 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32614 3691 : storageArray++ ;
32615 : }
32616 : }
32617 2 : delete [] storageArraySgExprListExp;
32618 2 : SgExprListExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
32619 :
32620 :
32621 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExprStatement );
32622 2 : SgExprStatementStorageClass* storageArraySgExprStatement = NULL;
32623 2 : if ( 0 < sizeOfActualPool )
32624 : {
32625 2210 : storageArraySgExprStatement = new SgExprStatementStorageClass[sizeOfActualPool] ;
32626 2 : inFile.read ( (char*) (storageArraySgExprStatement) , sizeof ( SgExprStatementStorageClass ) * sizeOfActualPool) ;
32627 2 : SgExprStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32628 : SgExprStatementStorageClass* storageArray = storageArraySgExprStatement;
32629 2210 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32630 : {
32631 2208 : SgExprStatement* tmp = new SgExprStatement ( *storageArray ) ;
32632 2208 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32633 2208 : storageArray++ ;
32634 : }
32635 : }
32636 2 : delete [] storageArraySgExprStatement;
32637 2 : SgExprStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32638 :
32639 :
32640 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExpression );
32641 2 : SgExpressionStorageClass* storageArraySgExpression = NULL;
32642 2 : if ( 0 < sizeOfActualPool )
32643 : {
32644 0 : storageArraySgExpression = new SgExpressionStorageClass[sizeOfActualPool] ;
32645 0 : inFile.read ( (char*) (storageArraySgExpression) , sizeof ( SgExpressionStorageClass ) * sizeOfActualPool) ;
32646 0 : SgExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
32647 : SgExpressionStorageClass* storageArray = storageArraySgExpression;
32648 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32649 : {
32650 0 : SgExpression* tmp = new SgExpression ( *storageArray ) ;
32651 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32652 0 : storageArray++ ;
32653 : }
32654 : }
32655 0 : delete [] storageArraySgExpression;
32656 2 : SgExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
32657 :
32658 :
32659 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgExpressionRoot );
32660 2 : SgExpressionRootStorageClass* storageArraySgExpressionRoot = NULL;
32661 2 : if ( 0 < sizeOfActualPool )
32662 : {
32663 0 : storageArraySgExpressionRoot = new SgExpressionRootStorageClass[sizeOfActualPool] ;
32664 0 : inFile.read ( (char*) (storageArraySgExpressionRoot) , sizeof ( SgExpressionRootStorageClass ) * sizeOfActualPool) ;
32665 0 : SgExpressionRootStorageClass :: readEasyStorageDataFromFile(inFile) ;
32666 : SgExpressionRootStorageClass* storageArray = storageArraySgExpressionRoot;
32667 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32668 : {
32669 0 : SgExpressionRoot* tmp = new SgExpressionRoot ( *storageArray ) ;
32670 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32671 0 : storageArray++ ;
32672 : }
32673 : }
32674 0 : delete [] storageArraySgExpressionRoot;
32675 2 : SgExpressionRootStorageClass :: deleteStaticDataOfEasyStorageClasses();
32676 :
32677 :
32678 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFile );
32679 2 : SgFileStorageClass* storageArraySgFile = NULL;
32680 2 : if ( 0 < sizeOfActualPool )
32681 : {
32682 0 : storageArraySgFile = new SgFileStorageClass[sizeOfActualPool] ;
32683 0 : inFile.read ( (char*) (storageArraySgFile) , sizeof ( SgFileStorageClass ) * sizeOfActualPool) ;
32684 0 : SgFileStorageClass :: readEasyStorageDataFromFile(inFile) ;
32685 : SgFileStorageClass* storageArray = storageArraySgFile;
32686 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32687 : {
32688 0 : SgFile* tmp = new SgFile ( *storageArray ) ;
32689 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32690 0 : storageArray++ ;
32691 : }
32692 : }
32693 0 : delete [] storageArraySgFile;
32694 2 : SgFileStorageClass :: deleteStaticDataOfEasyStorageClasses();
32695 :
32696 :
32697 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFileList );
32698 2 : SgFileListStorageClass* storageArraySgFileList = NULL;
32699 2 : if ( 0 < sizeOfActualPool )
32700 : {
32701 4 : storageArraySgFileList = new SgFileListStorageClass[sizeOfActualPool] ;
32702 2 : inFile.read ( (char*) (storageArraySgFileList) , sizeof ( SgFileListStorageClass ) * sizeOfActualPool) ;
32703 2 : SgFileListStorageClass :: readEasyStorageDataFromFile(inFile) ;
32704 : SgFileListStorageClass* storageArray = storageArraySgFileList;
32705 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32706 : {
32707 2 : SgFileList* tmp = new SgFileList ( *storageArray ) ;
32708 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32709 2 : storageArray++ ;
32710 : }
32711 : }
32712 2 : delete [] storageArraySgFileList;
32713 2 : SgFileListStorageClass :: deleteStaticDataOfEasyStorageClasses();
32714 :
32715 :
32716 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFloatVal );
32717 2 : SgFloatValStorageClass* storageArraySgFloatVal = NULL;
32718 2 : if ( 0 < sizeOfActualPool )
32719 : {
32720 2 : storageArraySgFloatVal = new SgFloatValStorageClass[sizeOfActualPool] ;
32721 1 : inFile.read ( (char*) (storageArraySgFloatVal) , sizeof ( SgFloatValStorageClass ) * sizeOfActualPool) ;
32722 1 : SgFloatValStorageClass :: readEasyStorageDataFromFile(inFile) ;
32723 : SgFloatValStorageClass* storageArray = storageArraySgFloatVal;
32724 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32725 : {
32726 1 : SgFloatVal* tmp = new SgFloatVal ( *storageArray ) ;
32727 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32728 1 : storageArray++ ;
32729 : }
32730 : }
32731 1 : delete [] storageArraySgFloatVal;
32732 2 : SgFloatValStorageClass :: deleteStaticDataOfEasyStorageClasses();
32733 :
32734 :
32735 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFloat128Val );
32736 2 : SgFloat128ValStorageClass* storageArraySgFloat128Val = NULL;
32737 2 : if ( 0 < sizeOfActualPool )
32738 : {
32739 0 : storageArraySgFloat128Val = new SgFloat128ValStorageClass[sizeOfActualPool] ;
32740 0 : inFile.read ( (char*) (storageArraySgFloat128Val) , sizeof ( SgFloat128ValStorageClass ) * sizeOfActualPool) ;
32741 0 : SgFloat128ValStorageClass :: readEasyStorageDataFromFile(inFile) ;
32742 : SgFloat128ValStorageClass* storageArray = storageArraySgFloat128Val;
32743 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32744 : {
32745 0 : SgFloat128Val* tmp = new SgFloat128Val ( *storageArray ) ;
32746 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32747 0 : storageArray++ ;
32748 : }
32749 : }
32750 0 : delete [] storageArraySgFloat128Val;
32751 2 : SgFloat128ValStorageClass :: deleteStaticDataOfEasyStorageClasses();
32752 :
32753 :
32754 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFloat80Val );
32755 2 : SgFloat80ValStorageClass* storageArraySgFloat80Val = NULL;
32756 2 : if ( 0 < sizeOfActualPool )
32757 : {
32758 0 : storageArraySgFloat80Val = new SgFloat80ValStorageClass[sizeOfActualPool] ;
32759 0 : inFile.read ( (char*) (storageArraySgFloat80Val) , sizeof ( SgFloat80ValStorageClass ) * sizeOfActualPool) ;
32760 0 : SgFloat80ValStorageClass :: readEasyStorageDataFromFile(inFile) ;
32761 : SgFloat80ValStorageClass* storageArray = storageArraySgFloat80Val;
32762 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32763 : {
32764 0 : SgFloat80Val* tmp = new SgFloat80Val ( *storageArray ) ;
32765 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32766 0 : storageArray++ ;
32767 : }
32768 : }
32769 0 : delete [] storageArraySgFloat80Val;
32770 2 : SgFloat80ValStorageClass :: deleteStaticDataOfEasyStorageClasses();
32771 :
32772 :
32773 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFoldExpression );
32774 2 : SgFoldExpressionStorageClass* storageArraySgFoldExpression = NULL;
32775 2 : if ( 0 < sizeOfActualPool )
32776 : {
32777 0 : storageArraySgFoldExpression = new SgFoldExpressionStorageClass[sizeOfActualPool] ;
32778 0 : inFile.read ( (char*) (storageArraySgFoldExpression) , sizeof ( SgFoldExpressionStorageClass ) * sizeOfActualPool) ;
32779 0 : SgFoldExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
32780 : SgFoldExpressionStorageClass* storageArray = storageArraySgFoldExpression;
32781 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32782 : {
32783 0 : SgFoldExpression* tmp = new SgFoldExpression ( *storageArray ) ;
32784 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32785 0 : storageArray++ ;
32786 : }
32787 : }
32788 0 : delete [] storageArraySgFoldExpression;
32789 2 : SgFoldExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
32790 :
32791 :
32792 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFlushStatement );
32793 2 : SgFlushStatementStorageClass* storageArraySgFlushStatement = NULL;
32794 2 : if ( 0 < sizeOfActualPool )
32795 : {
32796 0 : storageArraySgFlushStatement = new SgFlushStatementStorageClass[sizeOfActualPool] ;
32797 0 : inFile.read ( (char*) (storageArraySgFlushStatement) , sizeof ( SgFlushStatementStorageClass ) * sizeOfActualPool) ;
32798 0 : SgFlushStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32799 : SgFlushStatementStorageClass* storageArray = storageArraySgFlushStatement;
32800 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32801 : {
32802 0 : SgFlushStatement* tmp = new SgFlushStatement ( *storageArray ) ;
32803 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32804 0 : storageArray++ ;
32805 : }
32806 : }
32807 0 : delete [] storageArraySgFlushStatement;
32808 2 : SgFlushStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32809 :
32810 :
32811 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgForAllStatement );
32812 2 : SgForAllStatementStorageClass* storageArraySgForAllStatement = NULL;
32813 2 : if ( 0 < sizeOfActualPool )
32814 : {
32815 0 : storageArraySgForAllStatement = new SgForAllStatementStorageClass[sizeOfActualPool] ;
32816 0 : inFile.read ( (char*) (storageArraySgForAllStatement) , sizeof ( SgForAllStatementStorageClass ) * sizeOfActualPool) ;
32817 0 : SgForAllStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32818 : SgForAllStatementStorageClass* storageArray = storageArraySgForAllStatement;
32819 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32820 : {
32821 0 : SgForAllStatement* tmp = new SgForAllStatement ( *storageArray ) ;
32822 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32823 0 : storageArray++ ;
32824 : }
32825 : }
32826 0 : delete [] storageArraySgForAllStatement;
32827 2 : SgForAllStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32828 :
32829 :
32830 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgForInitStatement );
32831 2 : SgForInitStatementStorageClass* storageArraySgForInitStatement = NULL;
32832 2 : if ( 0 < sizeOfActualPool )
32833 : {
32834 41 : storageArraySgForInitStatement = new SgForInitStatementStorageClass[sizeOfActualPool] ;
32835 1 : inFile.read ( (char*) (storageArraySgForInitStatement) , sizeof ( SgForInitStatementStorageClass ) * sizeOfActualPool) ;
32836 1 : SgForInitStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32837 : SgForInitStatementStorageClass* storageArray = storageArraySgForInitStatement;
32838 41 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32839 : {
32840 40 : SgForInitStatement* tmp = new SgForInitStatement ( *storageArray ) ;
32841 40 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32842 40 : storageArray++ ;
32843 : }
32844 : }
32845 1 : delete [] storageArraySgForInitStatement;
32846 2 : SgForInitStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32847 :
32848 :
32849 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgForStatement );
32850 2 : SgForStatementStorageClass* storageArraySgForStatement = NULL;
32851 2 : if ( 0 < sizeOfActualPool )
32852 : {
32853 41 : storageArraySgForStatement = new SgForStatementStorageClass[sizeOfActualPool] ;
32854 1 : inFile.read ( (char*) (storageArraySgForStatement) , sizeof ( SgForStatementStorageClass ) * sizeOfActualPool) ;
32855 1 : SgForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32856 : SgForStatementStorageClass* storageArray = storageArraySgForStatement;
32857 41 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32858 : {
32859 40 : SgForStatement* tmp = new SgForStatement ( *storageArray ) ;
32860 40 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32861 40 : storageArray++ ;
32862 : }
32863 : }
32864 1 : delete [] storageArraySgForStatement;
32865 2 : SgForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32866 :
32867 :
32868 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFormatItem );
32869 2 : SgFormatItemStorageClass* storageArraySgFormatItem = NULL;
32870 2 : if ( 0 < sizeOfActualPool )
32871 : {
32872 0 : storageArraySgFormatItem = new SgFormatItemStorageClass[sizeOfActualPool] ;
32873 0 : inFile.read ( (char*) (storageArraySgFormatItem) , sizeof ( SgFormatItemStorageClass ) * sizeOfActualPool) ;
32874 : SgFormatItemStorageClass* storageArray = storageArraySgFormatItem;
32875 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32876 : {
32877 0 : SgFormatItem* tmp = new SgFormatItem ( *storageArray ) ;
32878 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32879 0 : storageArray++ ;
32880 : }
32881 : }
32882 0 : delete [] storageArraySgFormatItem;
32883 :
32884 :
32885 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFormatItemList );
32886 2 : SgFormatItemListStorageClass* storageArraySgFormatItemList = NULL;
32887 2 : if ( 0 < sizeOfActualPool )
32888 : {
32889 0 : storageArraySgFormatItemList = new SgFormatItemListStorageClass[sizeOfActualPool] ;
32890 0 : inFile.read ( (char*) (storageArraySgFormatItemList) , sizeof ( SgFormatItemListStorageClass ) * sizeOfActualPool) ;
32891 0 : SgFormatItemListStorageClass :: readEasyStorageDataFromFile(inFile) ;
32892 : SgFormatItemListStorageClass* storageArray = storageArraySgFormatItemList;
32893 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32894 : {
32895 0 : SgFormatItemList* tmp = new SgFormatItemList ( *storageArray ) ;
32896 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32897 0 : storageArray++ ;
32898 : }
32899 : }
32900 0 : delete [] storageArraySgFormatItemList;
32901 2 : SgFormatItemListStorageClass :: deleteStaticDataOfEasyStorageClasses();
32902 :
32903 :
32904 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFormatStatement );
32905 2 : SgFormatStatementStorageClass* storageArraySgFormatStatement = NULL;
32906 2 : if ( 0 < sizeOfActualPool )
32907 : {
32908 0 : storageArraySgFormatStatement = new SgFormatStatementStorageClass[sizeOfActualPool] ;
32909 0 : inFile.read ( (char*) (storageArraySgFormatStatement) , sizeof ( SgFormatStatementStorageClass ) * sizeOfActualPool) ;
32910 0 : SgFormatStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
32911 : SgFormatStatementStorageClass* storageArray = storageArraySgFormatStatement;
32912 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32913 : {
32914 0 : SgFormatStatement* tmp = new SgFormatStatement ( *storageArray ) ;
32915 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32916 0 : storageArray++ ;
32917 : }
32918 : }
32919 0 : delete [] storageArraySgFormatStatement;
32920 2 : SgFormatStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
32921 :
32922 :
32923 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFortranDo );
32924 2 : SgFortranDoStorageClass* storageArraySgFortranDo = NULL;
32925 2 : if ( 0 < sizeOfActualPool )
32926 : {
32927 0 : storageArraySgFortranDo = new SgFortranDoStorageClass[sizeOfActualPool] ;
32928 0 : inFile.read ( (char*) (storageArraySgFortranDo) , sizeof ( SgFortranDoStorageClass ) * sizeOfActualPool) ;
32929 0 : SgFortranDoStorageClass :: readEasyStorageDataFromFile(inFile) ;
32930 : SgFortranDoStorageClass* storageArray = storageArraySgFortranDo;
32931 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32932 : {
32933 0 : SgFortranDo* tmp = new SgFortranDo ( *storageArray ) ;
32934 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32935 0 : storageArray++ ;
32936 : }
32937 : }
32938 0 : delete [] storageArraySgFortranDo;
32939 2 : SgFortranDoStorageClass :: deleteStaticDataOfEasyStorageClasses();
32940 :
32941 :
32942 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFortranIncludeLine );
32943 2 : SgFortranIncludeLineStorageClass* storageArraySgFortranIncludeLine = NULL;
32944 2 : if ( 0 < sizeOfActualPool )
32945 : {
32946 0 : storageArraySgFortranIncludeLine = new SgFortranIncludeLineStorageClass[sizeOfActualPool] ;
32947 0 : inFile.read ( (char*) (storageArraySgFortranIncludeLine) , sizeof ( SgFortranIncludeLineStorageClass ) * sizeOfActualPool) ;
32948 0 : SgFortranIncludeLineStorageClass :: readEasyStorageDataFromFile(inFile) ;
32949 : SgFortranIncludeLineStorageClass* storageArray = storageArraySgFortranIncludeLine;
32950 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32951 : {
32952 0 : SgFortranIncludeLine* tmp = new SgFortranIncludeLine ( *storageArray ) ;
32953 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32954 0 : storageArray++ ;
32955 : }
32956 : }
32957 0 : delete [] storageArraySgFortranIncludeLine;
32958 2 : SgFortranIncludeLineStorageClass :: deleteStaticDataOfEasyStorageClasses();
32959 :
32960 :
32961 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFortranNonblockedDo );
32962 2 : SgFortranNonblockedDoStorageClass* storageArraySgFortranNonblockedDo = NULL;
32963 2 : if ( 0 < sizeOfActualPool )
32964 : {
32965 0 : storageArraySgFortranNonblockedDo = new SgFortranNonblockedDoStorageClass[sizeOfActualPool] ;
32966 0 : inFile.read ( (char*) (storageArraySgFortranNonblockedDo) , sizeof ( SgFortranNonblockedDoStorageClass ) * sizeOfActualPool) ;
32967 0 : SgFortranNonblockedDoStorageClass :: readEasyStorageDataFromFile(inFile) ;
32968 : SgFortranNonblockedDoStorageClass* storageArray = storageArraySgFortranNonblockedDo;
32969 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32970 : {
32971 0 : SgFortranNonblockedDo* tmp = new SgFortranNonblockedDo ( *storageArray ) ;
32972 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32973 0 : storageArray++ ;
32974 : }
32975 : }
32976 0 : delete [] storageArraySgFortranNonblockedDo;
32977 2 : SgFortranNonblockedDoStorageClass :: deleteStaticDataOfEasyStorageClasses();
32978 :
32979 :
32980 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFuncDecl_attr );
32981 2 : SgFuncDecl_attrStorageClass* storageArraySgFuncDecl_attr = NULL;
32982 2 : if ( 0 < sizeOfActualPool )
32983 : {
32984 0 : storageArraySgFuncDecl_attr = new SgFuncDecl_attrStorageClass[sizeOfActualPool] ;
32985 0 : inFile.read ( (char*) (storageArraySgFuncDecl_attr) , sizeof ( SgFuncDecl_attrStorageClass ) * sizeOfActualPool) ;
32986 0 : SgFuncDecl_attrStorageClass :: readEasyStorageDataFromFile(inFile) ;
32987 : SgFuncDecl_attrStorageClass* storageArray = storageArraySgFuncDecl_attr;
32988 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
32989 : {
32990 0 : SgFuncDecl_attr* tmp = new SgFuncDecl_attr ( *storageArray ) ;
32991 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
32992 0 : storageArray++ ;
32993 : }
32994 : }
32995 0 : delete [] storageArraySgFuncDecl_attr;
32996 2 : SgFuncDecl_attrStorageClass :: deleteStaticDataOfEasyStorageClasses();
32997 :
32998 :
32999 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionCallExp );
33000 2 : SgFunctionCallExpStorageClass* storageArraySgFunctionCallExp = NULL;
33001 2 : if ( 0 < sizeOfActualPool )
33002 : {
33003 3224 : storageArraySgFunctionCallExp = new SgFunctionCallExpStorageClass[sizeOfActualPool] ;
33004 2 : inFile.read ( (char*) (storageArraySgFunctionCallExp) , sizeof ( SgFunctionCallExpStorageClass ) * sizeOfActualPool) ;
33005 2 : SgFunctionCallExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33006 : SgFunctionCallExpStorageClass* storageArray = storageArraySgFunctionCallExp;
33007 3224 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33008 : {
33009 3222 : SgFunctionCallExp* tmp = new SgFunctionCallExp ( *storageArray ) ;
33010 3222 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33011 3222 : storageArray++ ;
33012 : }
33013 : }
33014 2 : delete [] storageArraySgFunctionCallExp;
33015 2 : SgFunctionCallExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33016 :
33017 :
33018 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionDeclaration );
33019 2 : SgFunctionDeclarationStorageClass* storageArraySgFunctionDeclaration = NULL;
33020 2 : if ( 0 < sizeOfActualPool )
33021 : {
33022 7918 : storageArraySgFunctionDeclaration = new SgFunctionDeclarationStorageClass[sizeOfActualPool] ;
33023 2 : inFile.read ( (char*) (storageArraySgFunctionDeclaration) , sizeof ( SgFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
33024 2 : SgFunctionDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
33025 : SgFunctionDeclarationStorageClass* storageArray = storageArraySgFunctionDeclaration;
33026 7918 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33027 : {
33028 7916 : SgFunctionDeclaration* tmp = new SgFunctionDeclaration ( *storageArray ) ;
33029 7916 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33030 7916 : storageArray++ ;
33031 : }
33032 : }
33033 2 : delete [] storageArraySgFunctionDeclaration;
33034 2 : SgFunctionDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
33035 :
33036 :
33037 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionDefinition );
33038 2 : SgFunctionDefinitionStorageClass* storageArraySgFunctionDefinition = NULL;
33039 2 : if ( 0 < sizeOfActualPool )
33040 : {
33041 1584 : storageArraySgFunctionDefinition = new SgFunctionDefinitionStorageClass[sizeOfActualPool] ;
33042 2 : inFile.read ( (char*) (storageArraySgFunctionDefinition) , sizeof ( SgFunctionDefinitionStorageClass ) * sizeOfActualPool) ;
33043 2 : SgFunctionDefinitionStorageClass :: readEasyStorageDataFromFile(inFile) ;
33044 : SgFunctionDefinitionStorageClass* storageArray = storageArraySgFunctionDefinition;
33045 1584 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33046 : {
33047 1582 : SgFunctionDefinition* tmp = new SgFunctionDefinition ( *storageArray ) ;
33048 1582 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33049 1582 : storageArray++ ;
33050 : }
33051 : }
33052 2 : delete [] storageArraySgFunctionDefinition;
33053 2 : SgFunctionDefinitionStorageClass :: deleteStaticDataOfEasyStorageClasses();
33054 :
33055 :
33056 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionParameterScope );
33057 2 : SgFunctionParameterScopeStorageClass* storageArraySgFunctionParameterScope = NULL;
33058 2 : if ( 0 < sizeOfActualPool )
33059 : {
33060 0 : storageArraySgFunctionParameterScope = new SgFunctionParameterScopeStorageClass[sizeOfActualPool] ;
33061 0 : inFile.read ( (char*) (storageArraySgFunctionParameterScope) , sizeof ( SgFunctionParameterScopeStorageClass ) * sizeOfActualPool) ;
33062 0 : SgFunctionParameterScopeStorageClass :: readEasyStorageDataFromFile(inFile) ;
33063 : SgFunctionParameterScopeStorageClass* storageArray = storageArraySgFunctionParameterScope;
33064 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33065 : {
33066 0 : SgFunctionParameterScope* tmp = new SgFunctionParameterScope ( *storageArray ) ;
33067 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33068 0 : storageArray++ ;
33069 : }
33070 : }
33071 0 : delete [] storageArraySgFunctionParameterScope;
33072 2 : SgFunctionParameterScopeStorageClass :: deleteStaticDataOfEasyStorageClasses();
33073 :
33074 :
33075 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionModifier );
33076 2 : SgFunctionModifierStorageClass* storageArraySgFunctionModifier = NULL;
33077 2 : if ( 0 < sizeOfActualPool )
33078 : {
33079 0 : storageArraySgFunctionModifier = new SgFunctionModifierStorageClass[sizeOfActualPool] ;
33080 0 : inFile.read ( (char*) (storageArraySgFunctionModifier) , sizeof ( SgFunctionModifierStorageClass ) * sizeOfActualPool) ;
33081 0 : SgFunctionModifierStorageClass :: readEasyStorageDataFromFile(inFile) ;
33082 : SgFunctionModifierStorageClass* storageArray = storageArraySgFunctionModifier;
33083 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33084 : {
33085 0 : SgFunctionModifier* tmp = new SgFunctionModifier ( *storageArray ) ;
33086 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33087 0 : storageArray++ ;
33088 : }
33089 : }
33090 0 : delete [] storageArraySgFunctionModifier;
33091 2 : SgFunctionModifierStorageClass :: deleteStaticDataOfEasyStorageClasses();
33092 :
33093 :
33094 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionParameterList );
33095 2 : SgFunctionParameterListStorageClass* storageArraySgFunctionParameterList = NULL;
33096 2 : if ( 0 < sizeOfActualPool )
33097 : {
33098 22769 : storageArraySgFunctionParameterList = new SgFunctionParameterListStorageClass[sizeOfActualPool] ;
33099 2 : inFile.read ( (char*) (storageArraySgFunctionParameterList) , sizeof ( SgFunctionParameterListStorageClass ) * sizeOfActualPool) ;
33100 2 : SgFunctionParameterListStorageClass :: readEasyStorageDataFromFile(inFile) ;
33101 : SgFunctionParameterListStorageClass* storageArray = storageArraySgFunctionParameterList;
33102 22769 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33103 : {
33104 22767 : SgFunctionParameterList* tmp = new SgFunctionParameterList ( *storageArray ) ;
33105 22767 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33106 22767 : storageArray++ ;
33107 : }
33108 : }
33109 2 : delete [] storageArraySgFunctionParameterList;
33110 2 : SgFunctionParameterListStorageClass :: deleteStaticDataOfEasyStorageClasses();
33111 :
33112 :
33113 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionParameterRefExp );
33114 2 : SgFunctionParameterRefExpStorageClass* storageArraySgFunctionParameterRefExp = NULL;
33115 2 : if ( 0 < sizeOfActualPool )
33116 : {
33117 68 : storageArraySgFunctionParameterRefExp = new SgFunctionParameterRefExpStorageClass[sizeOfActualPool] ;
33118 1 : inFile.read ( (char*) (storageArraySgFunctionParameterRefExp) , sizeof ( SgFunctionParameterRefExpStorageClass ) * sizeOfActualPool) ;
33119 1 : SgFunctionParameterRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33120 : SgFunctionParameterRefExpStorageClass* storageArray = storageArraySgFunctionParameterRefExp;
33121 68 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33122 : {
33123 67 : SgFunctionParameterRefExp* tmp = new SgFunctionParameterRefExp ( *storageArray ) ;
33124 67 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33125 67 : storageArray++ ;
33126 : }
33127 : }
33128 1 : delete [] storageArraySgFunctionParameterRefExp;
33129 2 : SgFunctionParameterRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33130 :
33131 :
33132 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionParameterTypeList );
33133 2 : SgFunctionParameterTypeListStorageClass* storageArraySgFunctionParameterTypeList = NULL;
33134 2 : if ( 0 < sizeOfActualPool )
33135 : {
33136 8412 : storageArraySgFunctionParameterTypeList = new SgFunctionParameterTypeListStorageClass[sizeOfActualPool] ;
33137 2 : inFile.read ( (char*) (storageArraySgFunctionParameterTypeList) , sizeof ( SgFunctionParameterTypeListStorageClass ) * sizeOfActualPool) ;
33138 2 : SgFunctionParameterTypeListStorageClass :: readEasyStorageDataFromFile(inFile) ;
33139 : SgFunctionParameterTypeListStorageClass* storageArray = storageArraySgFunctionParameterTypeList;
33140 8412 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33141 : {
33142 8410 : SgFunctionParameterTypeList* tmp = new SgFunctionParameterTypeList ( *storageArray ) ;
33143 8410 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33144 8410 : storageArray++ ;
33145 : }
33146 : }
33147 2 : delete [] storageArraySgFunctionParameterTypeList;
33148 2 : SgFunctionParameterTypeListStorageClass :: deleteStaticDataOfEasyStorageClasses();
33149 :
33150 :
33151 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionRefExp );
33152 2 : SgFunctionRefExpStorageClass* storageArraySgFunctionRefExp = NULL;
33153 2 : if ( 0 < sizeOfActualPool )
33154 : {
33155 610 : storageArraySgFunctionRefExp = new SgFunctionRefExpStorageClass[sizeOfActualPool] ;
33156 2 : inFile.read ( (char*) (storageArraySgFunctionRefExp) , sizeof ( SgFunctionRefExpStorageClass ) * sizeOfActualPool) ;
33157 2 : SgFunctionRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33158 : SgFunctionRefExpStorageClass* storageArray = storageArraySgFunctionRefExp;
33159 610 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33160 : {
33161 608 : SgFunctionRefExp* tmp = new SgFunctionRefExp ( *storageArray ) ;
33162 608 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33163 608 : storageArray++ ;
33164 : }
33165 : }
33166 2 : delete [] storageArraySgFunctionRefExp;
33167 2 : SgFunctionRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33168 :
33169 :
33170 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionSymbol );
33171 2 : SgFunctionSymbolStorageClass* storageArraySgFunctionSymbol = NULL;
33172 2 : if ( 0 < sizeOfActualPool )
33173 : {
33174 5957 : storageArraySgFunctionSymbol = new SgFunctionSymbolStorageClass[sizeOfActualPool] ;
33175 2 : inFile.read ( (char*) (storageArraySgFunctionSymbol) , sizeof ( SgFunctionSymbolStorageClass ) * sizeOfActualPool) ;
33176 2 : SgFunctionSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
33177 : SgFunctionSymbolStorageClass* storageArray = storageArraySgFunctionSymbol;
33178 5957 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33179 : {
33180 5955 : SgFunctionSymbol* tmp = new SgFunctionSymbol ( *storageArray ) ;
33181 5955 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33182 5955 : storageArray++ ;
33183 : }
33184 : }
33185 2 : delete [] storageArraySgFunctionSymbol;
33186 2 : SgFunctionSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
33187 :
33188 :
33189 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionType );
33190 2 : SgFunctionTypeStorageClass* storageArraySgFunctionType = NULL;
33191 2 : if ( 0 < sizeOfActualPool )
33192 : {
33193 3151 : storageArraySgFunctionType = new SgFunctionTypeStorageClass[sizeOfActualPool] ;
33194 2 : inFile.read ( (char*) (storageArraySgFunctionType) , sizeof ( SgFunctionTypeStorageClass ) * sizeOfActualPool) ;
33195 2 : SgFunctionTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
33196 : SgFunctionTypeStorageClass* storageArray = storageArraySgFunctionType;
33197 3151 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33198 : {
33199 3149 : SgFunctionType* tmp = new SgFunctionType ( *storageArray ) ;
33200 3149 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33201 3149 : storageArray++ ;
33202 : }
33203 : }
33204 2 : delete [] storageArraySgFunctionType;
33205 2 : SgFunctionTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
33206 :
33207 :
33208 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionTypeSymbol );
33209 2 : SgFunctionTypeSymbolStorageClass* storageArraySgFunctionTypeSymbol = NULL;
33210 2 : if ( 0 < sizeOfActualPool )
33211 : {
33212 9183 : storageArraySgFunctionTypeSymbol = new SgFunctionTypeSymbolStorageClass[sizeOfActualPool] ;
33213 2 : inFile.read ( (char*) (storageArraySgFunctionTypeSymbol) , sizeof ( SgFunctionTypeSymbolStorageClass ) * sizeOfActualPool) ;
33214 2 : SgFunctionTypeSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
33215 : SgFunctionTypeSymbolStorageClass* storageArray = storageArraySgFunctionTypeSymbol;
33216 9183 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33217 : {
33218 9181 : SgFunctionTypeSymbol* tmp = new SgFunctionTypeSymbol ( *storageArray ) ;
33219 9181 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33220 9181 : storageArray++ ;
33221 : }
33222 : }
33223 2 : delete [] storageArraySgFunctionTypeSymbol;
33224 2 : SgFunctionTypeSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
33225 :
33226 :
33227 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgFunctionTypeTable );
33228 2 : SgFunctionTypeTableStorageClass* storageArraySgFunctionTypeTable = NULL;
33229 2 : if ( 0 < sizeOfActualPool )
33230 : {
33231 4 : storageArraySgFunctionTypeTable = new SgFunctionTypeTableStorageClass[sizeOfActualPool] ;
33232 2 : inFile.read ( (char*) (storageArraySgFunctionTypeTable) , sizeof ( SgFunctionTypeTableStorageClass ) * sizeOfActualPool) ;
33233 2 : SgFunctionTypeTableStorageClass :: readEasyStorageDataFromFile(inFile) ;
33234 : SgFunctionTypeTableStorageClass* storageArray = storageArraySgFunctionTypeTable;
33235 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33236 : {
33237 2 : SgFunctionTypeTable* tmp = new SgFunctionTypeTable ( *storageArray ) ;
33238 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33239 2 : storageArray++ ;
33240 : }
33241 : }
33242 2 : delete [] storageArraySgFunctionTypeTable;
33243 2 : SgFunctionTypeTableStorageClass :: deleteStaticDataOfEasyStorageClasses();
33244 :
33245 :
33246 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeTable );
33247 2 : SgTypeTableStorageClass* storageArraySgTypeTable = NULL;
33248 2 : if ( 0 < sizeOfActualPool )
33249 : {
33250 2 : storageArraySgTypeTable = new SgTypeTableStorageClass[sizeOfActualPool] ;
33251 2 : inFile.read ( (char*) (storageArraySgTypeTable) , sizeof ( SgTypeTableStorageClass ) * sizeOfActualPool) ;
33252 : SgTypeTableStorageClass* storageArray = storageArraySgTypeTable;
33253 13452 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33254 : {
33255 13450 : SgTypeTable* tmp = new SgTypeTable ( *storageArray ) ;
33256 13450 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33257 13450 : storageArray++ ;
33258 : }
33259 : }
33260 2 : delete [] storageArraySgTypeTable;
33261 :
33262 :
33263 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGlobal );
33264 2 : SgGlobalStorageClass* storageArraySgGlobal = NULL;
33265 2 : if ( 0 < sizeOfActualPool )
33266 : {
33267 6 : storageArraySgGlobal = new SgGlobalStorageClass[sizeOfActualPool] ;
33268 2 : inFile.read ( (char*) (storageArraySgGlobal) , sizeof ( SgGlobalStorageClass ) * sizeOfActualPool) ;
33269 2 : SgGlobalStorageClass :: readEasyStorageDataFromFile(inFile) ;
33270 : SgGlobalStorageClass* storageArray = storageArraySgGlobal;
33271 6 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33272 : {
33273 4 : SgGlobal* tmp = new SgGlobal ( *storageArray ) ;
33274 4 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33275 4 : storageArray++ ;
33276 : }
33277 : }
33278 2 : delete [] storageArraySgGlobal;
33279 2 : SgGlobalStorageClass :: deleteStaticDataOfEasyStorageClasses();
33280 :
33281 :
33282 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGotoStatement );
33283 2 : SgGotoStatementStorageClass* storageArraySgGotoStatement = NULL;
33284 2 : if ( 0 < sizeOfActualPool )
33285 : {
33286 0 : storageArraySgGotoStatement = new SgGotoStatementStorageClass[sizeOfActualPool] ;
33287 0 : inFile.read ( (char*) (storageArraySgGotoStatement) , sizeof ( SgGotoStatementStorageClass ) * sizeOfActualPool) ;
33288 0 : SgGotoStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33289 : SgGotoStatementStorageClass* storageArray = storageArraySgGotoStatement;
33290 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33291 : {
33292 0 : SgGotoStatement* tmp = new SgGotoStatement ( *storageArray ) ;
33293 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33294 0 : storageArray++ ;
33295 : }
33296 : }
33297 0 : delete [] storageArraySgGotoStatement;
33298 2 : SgGotoStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33299 :
33300 :
33301 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGraph );
33302 2 : SgGraphStorageClass* storageArraySgGraph = NULL;
33303 2 : if ( 0 < sizeOfActualPool )
33304 : {
33305 0 : storageArraySgGraph = new SgGraphStorageClass[sizeOfActualPool] ;
33306 0 : inFile.read ( (char*) (storageArraySgGraph) , sizeof ( SgGraphStorageClass ) * sizeOfActualPool) ;
33307 0 : SgGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
33308 : SgGraphStorageClass* storageArray = storageArraySgGraph;
33309 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33310 : {
33311 0 : SgGraph* tmp = new SgGraph ( *storageArray ) ;
33312 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33313 0 : storageArray++ ;
33314 : }
33315 : }
33316 0 : delete [] storageArraySgGraph;
33317 2 : SgGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
33318 :
33319 :
33320 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGraphEdge );
33321 2 : SgGraphEdgeStorageClass* storageArraySgGraphEdge = NULL;
33322 2 : if ( 0 < sizeOfActualPool )
33323 : {
33324 0 : storageArraySgGraphEdge = new SgGraphEdgeStorageClass[sizeOfActualPool] ;
33325 0 : inFile.read ( (char*) (storageArraySgGraphEdge) , sizeof ( SgGraphEdgeStorageClass ) * sizeOfActualPool) ;
33326 0 : SgGraphEdgeStorageClass :: readEasyStorageDataFromFile(inFile) ;
33327 : SgGraphEdgeStorageClass* storageArray = storageArraySgGraphEdge;
33328 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33329 : {
33330 0 : SgGraphEdge* tmp = new SgGraphEdge ( *storageArray ) ;
33331 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33332 0 : storageArray++ ;
33333 : }
33334 : }
33335 0 : delete [] storageArraySgGraphEdge;
33336 2 : SgGraphEdgeStorageClass :: deleteStaticDataOfEasyStorageClasses();
33337 :
33338 :
33339 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGraphEdgeList );
33340 2 : SgGraphEdgeListStorageClass* storageArraySgGraphEdgeList = NULL;
33341 2 : if ( 0 < sizeOfActualPool )
33342 : {
33343 0 : storageArraySgGraphEdgeList = new SgGraphEdgeListStorageClass[sizeOfActualPool] ;
33344 0 : inFile.read ( (char*) (storageArraySgGraphEdgeList) , sizeof ( SgGraphEdgeListStorageClass ) * sizeOfActualPool) ;
33345 : SgGraphEdgeListStorageClass* storageArray = storageArraySgGraphEdgeList;
33346 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33347 : {
33348 0 : SgGraphEdgeList* tmp = new SgGraphEdgeList ( *storageArray ) ;
33349 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33350 0 : storageArray++ ;
33351 : }
33352 : }
33353 0 : delete [] storageArraySgGraphEdgeList;
33354 :
33355 :
33356 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGraphNode );
33357 2 : SgGraphNodeStorageClass* storageArraySgGraphNode = NULL;
33358 2 : if ( 0 < sizeOfActualPool )
33359 : {
33360 0 : storageArraySgGraphNode = new SgGraphNodeStorageClass[sizeOfActualPool] ;
33361 0 : inFile.read ( (char*) (storageArraySgGraphNode) , sizeof ( SgGraphNodeStorageClass ) * sizeOfActualPool) ;
33362 0 : SgGraphNodeStorageClass :: readEasyStorageDataFromFile(inFile) ;
33363 : SgGraphNodeStorageClass* storageArray = storageArraySgGraphNode;
33364 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33365 : {
33366 0 : SgGraphNode* tmp = new SgGraphNode ( *storageArray ) ;
33367 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33368 0 : storageArray++ ;
33369 : }
33370 : }
33371 0 : delete [] storageArraySgGraphNode;
33372 2 : SgGraphNodeStorageClass :: deleteStaticDataOfEasyStorageClasses();
33373 :
33374 :
33375 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGraphNodeList );
33376 2 : SgGraphNodeListStorageClass* storageArraySgGraphNodeList = NULL;
33377 2 : if ( 0 < sizeOfActualPool )
33378 : {
33379 0 : storageArraySgGraphNodeList = new SgGraphNodeListStorageClass[sizeOfActualPool] ;
33380 0 : inFile.read ( (char*) (storageArraySgGraphNodeList) , sizeof ( SgGraphNodeListStorageClass ) * sizeOfActualPool) ;
33381 : SgGraphNodeListStorageClass* storageArray = storageArraySgGraphNodeList;
33382 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33383 : {
33384 0 : SgGraphNodeList* tmp = new SgGraphNodeList ( *storageArray ) ;
33385 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33386 0 : storageArray++ ;
33387 : }
33388 : }
33389 0 : delete [] storageArraySgGraphNodeList;
33390 :
33391 :
33392 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGreaterOrEqualOp );
33393 2 : SgGreaterOrEqualOpStorageClass* storageArraySgGreaterOrEqualOp = NULL;
33394 2 : if ( 0 < sizeOfActualPool )
33395 : {
33396 29 : storageArraySgGreaterOrEqualOp = new SgGreaterOrEqualOpStorageClass[sizeOfActualPool] ;
33397 1 : inFile.read ( (char*) (storageArraySgGreaterOrEqualOp) , sizeof ( SgGreaterOrEqualOpStorageClass ) * sizeOfActualPool) ;
33398 1 : SgGreaterOrEqualOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33399 : SgGreaterOrEqualOpStorageClass* storageArray = storageArraySgGreaterOrEqualOp;
33400 29 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33401 : {
33402 28 : SgGreaterOrEqualOp* tmp = new SgGreaterOrEqualOp ( *storageArray ) ;
33403 28 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33404 28 : storageArray++ ;
33405 : }
33406 : }
33407 1 : delete [] storageArraySgGreaterOrEqualOp;
33408 2 : SgGreaterOrEqualOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33409 :
33410 :
33411 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgGreaterThanOp );
33412 2 : SgGreaterThanOpStorageClass* storageArraySgGreaterThanOp = NULL;
33413 2 : if ( 0 < sizeOfActualPool )
33414 : {
33415 109 : storageArraySgGreaterThanOp = new SgGreaterThanOpStorageClass[sizeOfActualPool] ;
33416 1 : inFile.read ( (char*) (storageArraySgGreaterThanOp) , sizeof ( SgGreaterThanOpStorageClass ) * sizeOfActualPool) ;
33417 1 : SgGreaterThanOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33418 : SgGreaterThanOpStorageClass* storageArray = storageArraySgGreaterThanOp;
33419 109 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33420 : {
33421 108 : SgGreaterThanOp* tmp = new SgGreaterThanOp ( *storageArray ) ;
33422 108 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33423 108 : storageArray++ ;
33424 : }
33425 : }
33426 1 : delete [] storageArraySgGreaterThanOp;
33427 2 : SgGreaterThanOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33428 :
33429 :
33430 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIOItemExpression );
33431 2 : SgIOItemExpressionStorageClass* storageArraySgIOItemExpression = NULL;
33432 2 : if ( 0 < sizeOfActualPool )
33433 : {
33434 0 : storageArraySgIOItemExpression = new SgIOItemExpressionStorageClass[sizeOfActualPool] ;
33435 0 : inFile.read ( (char*) (storageArraySgIOItemExpression) , sizeof ( SgIOItemExpressionStorageClass ) * sizeOfActualPool) ;
33436 0 : SgIOItemExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
33437 : SgIOItemExpressionStorageClass* storageArray = storageArraySgIOItemExpression;
33438 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33439 : {
33440 0 : SgIOItemExpression* tmp = new SgIOItemExpression ( *storageArray ) ;
33441 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33442 0 : storageArray++ ;
33443 : }
33444 : }
33445 0 : delete [] storageArraySgIOItemExpression;
33446 2 : SgIOItemExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
33447 :
33448 :
33449 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIOStatement );
33450 2 : SgIOStatementStorageClass* storageArraySgIOStatement = NULL;
33451 2 : if ( 0 < sizeOfActualPool )
33452 : {
33453 0 : storageArraySgIOStatement = new SgIOStatementStorageClass[sizeOfActualPool] ;
33454 0 : inFile.read ( (char*) (storageArraySgIOStatement) , sizeof ( SgIOStatementStorageClass ) * sizeOfActualPool) ;
33455 0 : SgIOStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33456 : SgIOStatementStorageClass* storageArray = storageArraySgIOStatement;
33457 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33458 : {
33459 0 : SgIOStatement* tmp = new SgIOStatement ( *storageArray ) ;
33460 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33461 0 : storageArray++ ;
33462 : }
33463 : }
33464 0 : delete [] storageArraySgIOStatement;
33465 2 : SgIOStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33466 :
33467 :
33468 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIdentDirectiveStatement );
33469 2 : SgIdentDirectiveStatementStorageClass* storageArraySgIdentDirectiveStatement = NULL;
33470 2 : if ( 0 < sizeOfActualPool )
33471 : {
33472 0 : storageArraySgIdentDirectiveStatement = new SgIdentDirectiveStatementStorageClass[sizeOfActualPool] ;
33473 0 : inFile.read ( (char*) (storageArraySgIdentDirectiveStatement) , sizeof ( SgIdentDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33474 0 : SgIdentDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33475 : SgIdentDirectiveStatementStorageClass* storageArray = storageArraySgIdentDirectiveStatement;
33476 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33477 : {
33478 0 : SgIdentDirectiveStatement* tmp = new SgIdentDirectiveStatement ( *storageArray ) ;
33479 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33480 0 : storageArray++ ;
33481 : }
33482 : }
33483 0 : delete [] storageArraySgIdentDirectiveStatement;
33484 2 : SgIdentDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33485 :
33486 :
33487 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIfDirectiveStatement );
33488 2 : SgIfDirectiveStatementStorageClass* storageArraySgIfDirectiveStatement = NULL;
33489 2 : if ( 0 < sizeOfActualPool )
33490 : {
33491 0 : storageArraySgIfDirectiveStatement = new SgIfDirectiveStatementStorageClass[sizeOfActualPool] ;
33492 0 : inFile.read ( (char*) (storageArraySgIfDirectiveStatement) , sizeof ( SgIfDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33493 0 : SgIfDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33494 : SgIfDirectiveStatementStorageClass* storageArray = storageArraySgIfDirectiveStatement;
33495 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33496 : {
33497 0 : SgIfDirectiveStatement* tmp = new SgIfDirectiveStatement ( *storageArray ) ;
33498 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33499 0 : storageArray++ ;
33500 : }
33501 : }
33502 0 : delete [] storageArraySgIfDirectiveStatement;
33503 2 : SgIfDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33504 :
33505 :
33506 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIfStmt );
33507 2 : SgIfStmtStorageClass* storageArraySgIfStmt = NULL;
33508 2 : if ( 0 < sizeOfActualPool )
33509 : {
33510 593 : storageArraySgIfStmt = new SgIfStmtStorageClass[sizeOfActualPool] ;
33511 1 : inFile.read ( (char*) (storageArraySgIfStmt) , sizeof ( SgIfStmtStorageClass ) * sizeOfActualPool) ;
33512 1 : SgIfStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
33513 : SgIfStmtStorageClass* storageArray = storageArraySgIfStmt;
33514 593 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33515 : {
33516 592 : SgIfStmt* tmp = new SgIfStmt ( *storageArray ) ;
33517 592 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33518 592 : storageArray++ ;
33519 : }
33520 : }
33521 1 : delete [] storageArraySgIfStmt;
33522 2 : SgIfStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
33523 :
33524 :
33525 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIfdefDirectiveStatement );
33526 2 : SgIfdefDirectiveStatementStorageClass* storageArraySgIfdefDirectiveStatement = NULL;
33527 2 : if ( 0 < sizeOfActualPool )
33528 : {
33529 0 : storageArraySgIfdefDirectiveStatement = new SgIfdefDirectiveStatementStorageClass[sizeOfActualPool] ;
33530 0 : inFile.read ( (char*) (storageArraySgIfdefDirectiveStatement) , sizeof ( SgIfdefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33531 0 : SgIfdefDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33532 : SgIfdefDirectiveStatementStorageClass* storageArray = storageArraySgIfdefDirectiveStatement;
33533 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33534 : {
33535 0 : SgIfdefDirectiveStatement* tmp = new SgIfdefDirectiveStatement ( *storageArray ) ;
33536 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33537 0 : storageArray++ ;
33538 : }
33539 : }
33540 0 : delete [] storageArraySgIfdefDirectiveStatement;
33541 2 : SgIfdefDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33542 :
33543 :
33544 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIfndefDirectiveStatement );
33545 2 : SgIfndefDirectiveStatementStorageClass* storageArraySgIfndefDirectiveStatement = NULL;
33546 2 : if ( 0 < sizeOfActualPool )
33547 : {
33548 0 : storageArraySgIfndefDirectiveStatement = new SgIfndefDirectiveStatementStorageClass[sizeOfActualPool] ;
33549 0 : inFile.read ( (char*) (storageArraySgIfndefDirectiveStatement) , sizeof ( SgIfndefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33550 0 : SgIfndefDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33551 : SgIfndefDirectiveStatementStorageClass* storageArray = storageArraySgIfndefDirectiveStatement;
33552 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33553 : {
33554 0 : SgIfndefDirectiveStatement* tmp = new SgIfndefDirectiveStatement ( *storageArray ) ;
33555 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33556 0 : storageArray++ ;
33557 : }
33558 : }
33559 0 : delete [] storageArraySgIfndefDirectiveStatement;
33560 2 : SgIfndefDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33561 :
33562 :
33563 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgImageControlStatement );
33564 2 : SgImageControlStatementStorageClass* storageArraySgImageControlStatement = NULL;
33565 2 : if ( 0 < sizeOfActualPool )
33566 : {
33567 0 : storageArraySgImageControlStatement = new SgImageControlStatementStorageClass[sizeOfActualPool] ;
33568 0 : inFile.read ( (char*) (storageArraySgImageControlStatement) , sizeof ( SgImageControlStatementStorageClass ) * sizeOfActualPool) ;
33569 0 : SgImageControlStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33570 : SgImageControlStatementStorageClass* storageArray = storageArraySgImageControlStatement;
33571 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33572 : {
33573 0 : SgImageControlStatement* tmp = new SgImageControlStatement ( *storageArray ) ;
33574 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33575 0 : storageArray++ ;
33576 : }
33577 : }
33578 0 : delete [] storageArraySgImageControlStatement;
33579 2 : SgImageControlStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33580 :
33581 :
33582 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgImagPartOp );
33583 2 : SgImagPartOpStorageClass* storageArraySgImagPartOp = NULL;
33584 2 : if ( 0 < sizeOfActualPool )
33585 : {
33586 0 : storageArraySgImagPartOp = new SgImagPartOpStorageClass[sizeOfActualPool] ;
33587 0 : inFile.read ( (char*) (storageArraySgImagPartOp) , sizeof ( SgImagPartOpStorageClass ) * sizeOfActualPool) ;
33588 0 : SgImagPartOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33589 : SgImagPartOpStorageClass* storageArray = storageArraySgImagPartOp;
33590 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33591 : {
33592 0 : SgImagPartOp* tmp = new SgImagPartOp ( *storageArray ) ;
33593 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33594 0 : storageArray++ ;
33595 : }
33596 : }
33597 0 : delete [] storageArraySgImagPartOp;
33598 2 : SgImagPartOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33599 :
33600 :
33601 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgImplicitStatement );
33602 2 : SgImplicitStatementStorageClass* storageArraySgImplicitStatement = NULL;
33603 2 : if ( 0 < sizeOfActualPool )
33604 : {
33605 0 : storageArraySgImplicitStatement = new SgImplicitStatementStorageClass[sizeOfActualPool] ;
33606 0 : inFile.read ( (char*) (storageArraySgImplicitStatement) , sizeof ( SgImplicitStatementStorageClass ) * sizeOfActualPool) ;
33607 0 : SgImplicitStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33608 : SgImplicitStatementStorageClass* storageArray = storageArraySgImplicitStatement;
33609 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33610 : {
33611 0 : SgImplicitStatement* tmp = new SgImplicitStatement ( *storageArray ) ;
33612 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33613 0 : storageArray++ ;
33614 : }
33615 : }
33616 0 : delete [] storageArraySgImplicitStatement;
33617 2 : SgImplicitStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33618 :
33619 :
33620 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgImpliedDo );
33621 2 : SgImpliedDoStorageClass* storageArraySgImpliedDo = NULL;
33622 2 : if ( 0 < sizeOfActualPool )
33623 : {
33624 0 : storageArraySgImpliedDo = new SgImpliedDoStorageClass[sizeOfActualPool] ;
33625 0 : inFile.read ( (char*) (storageArraySgImpliedDo) , sizeof ( SgImpliedDoStorageClass ) * sizeOfActualPool) ;
33626 0 : SgImpliedDoStorageClass :: readEasyStorageDataFromFile(inFile) ;
33627 : SgImpliedDoStorageClass* storageArray = storageArraySgImpliedDo;
33628 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33629 : {
33630 0 : SgImpliedDo* tmp = new SgImpliedDo ( *storageArray ) ;
33631 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33632 0 : storageArray++ ;
33633 : }
33634 : }
33635 0 : delete [] storageArraySgImpliedDo;
33636 2 : SgImpliedDoStorageClass :: deleteStaticDataOfEasyStorageClasses();
33637 :
33638 :
33639 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgImportStatement );
33640 2 : SgImportStatementStorageClass* storageArraySgImportStatement = NULL;
33641 2 : if ( 0 < sizeOfActualPool )
33642 : {
33643 0 : storageArraySgImportStatement = new SgImportStatementStorageClass[sizeOfActualPool] ;
33644 0 : inFile.read ( (char*) (storageArraySgImportStatement) , sizeof ( SgImportStatementStorageClass ) * sizeOfActualPool) ;
33645 0 : SgImportStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33646 : SgImportStatementStorageClass* storageArray = storageArraySgImportStatement;
33647 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33648 : {
33649 0 : SgImportStatement* tmp = new SgImportStatement ( *storageArray ) ;
33650 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33651 0 : storageArray++ ;
33652 : }
33653 : }
33654 0 : delete [] storageArraySgImportStatement;
33655 2 : SgImportStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33656 :
33657 :
33658 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIncidenceDirectedGraph );
33659 2 : SgIncidenceDirectedGraphStorageClass* storageArraySgIncidenceDirectedGraph = NULL;
33660 2 : if ( 0 < sizeOfActualPool )
33661 : {
33662 0 : storageArraySgIncidenceDirectedGraph = new SgIncidenceDirectedGraphStorageClass[sizeOfActualPool] ;
33663 0 : inFile.read ( (char*) (storageArraySgIncidenceDirectedGraph) , sizeof ( SgIncidenceDirectedGraphStorageClass ) * sizeOfActualPool) ;
33664 0 : SgIncidenceDirectedGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
33665 : SgIncidenceDirectedGraphStorageClass* storageArray = storageArraySgIncidenceDirectedGraph;
33666 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33667 : {
33668 0 : SgIncidenceDirectedGraph* tmp = new SgIncidenceDirectedGraph ( *storageArray ) ;
33669 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33670 0 : storageArray++ ;
33671 : }
33672 : }
33673 0 : delete [] storageArraySgIncidenceDirectedGraph;
33674 2 : SgIncidenceDirectedGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
33675 :
33676 :
33677 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIncidenceUndirectedGraph );
33678 2 : SgIncidenceUndirectedGraphStorageClass* storageArraySgIncidenceUndirectedGraph = NULL;
33679 2 : if ( 0 < sizeOfActualPool )
33680 : {
33681 0 : storageArraySgIncidenceUndirectedGraph = new SgIncidenceUndirectedGraphStorageClass[sizeOfActualPool] ;
33682 0 : inFile.read ( (char*) (storageArraySgIncidenceUndirectedGraph) , sizeof ( SgIncidenceUndirectedGraphStorageClass ) * sizeOfActualPool) ;
33683 0 : SgIncidenceUndirectedGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
33684 : SgIncidenceUndirectedGraphStorageClass* storageArray = storageArraySgIncidenceUndirectedGraph;
33685 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33686 : {
33687 0 : SgIncidenceUndirectedGraph* tmp = new SgIncidenceUndirectedGraph ( *storageArray ) ;
33688 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33689 0 : storageArray++ ;
33690 : }
33691 : }
33692 0 : delete [] storageArraySgIncidenceUndirectedGraph;
33693 2 : SgIncidenceUndirectedGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
33694 :
33695 :
33696 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIncludeDirectiveStatement );
33697 2 : SgIncludeDirectiveStatementStorageClass* storageArraySgIncludeDirectiveStatement = NULL;
33698 2 : if ( 0 < sizeOfActualPool )
33699 : {
33700 0 : storageArraySgIncludeDirectiveStatement = new SgIncludeDirectiveStatementStorageClass[sizeOfActualPool] ;
33701 0 : inFile.read ( (char*) (storageArraySgIncludeDirectiveStatement) , sizeof ( SgIncludeDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33702 0 : SgIncludeDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33703 : SgIncludeDirectiveStatementStorageClass* storageArray = storageArraySgIncludeDirectiveStatement;
33704 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33705 : {
33706 0 : SgIncludeDirectiveStatement* tmp = new SgIncludeDirectiveStatement ( *storageArray ) ;
33707 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33708 0 : storageArray++ ;
33709 : }
33710 : }
33711 0 : delete [] storageArraySgIncludeDirectiveStatement;
33712 2 : SgIncludeDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33713 :
33714 :
33715 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIncludeFile );
33716 2 : SgIncludeFileStorageClass* storageArraySgIncludeFile = NULL;
33717 2 : if ( 0 < sizeOfActualPool )
33718 : {
33719 226 : storageArraySgIncludeFile = new SgIncludeFileStorageClass[sizeOfActualPool] ;
33720 2 : inFile.read ( (char*) (storageArraySgIncludeFile) , sizeof ( SgIncludeFileStorageClass ) * sizeOfActualPool) ;
33721 2 : SgIncludeFileStorageClass :: readEasyStorageDataFromFile(inFile) ;
33722 : SgIncludeFileStorageClass* storageArray = storageArraySgIncludeFile;
33723 226 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33724 : {
33725 224 : SgIncludeFile* tmp = new SgIncludeFile ( *storageArray ) ;
33726 224 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33727 224 : storageArray++ ;
33728 : }
33729 : }
33730 2 : delete [] storageArraySgIncludeFile;
33731 2 : SgIncludeFileStorageClass :: deleteStaticDataOfEasyStorageClasses();
33732 :
33733 :
33734 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIncludeNextDirectiveStatement );
33735 2 : SgIncludeNextDirectiveStatementStorageClass* storageArraySgIncludeNextDirectiveStatement = NULL;
33736 2 : if ( 0 < sizeOfActualPool )
33737 : {
33738 0 : storageArraySgIncludeNextDirectiveStatement = new SgIncludeNextDirectiveStatementStorageClass[sizeOfActualPool] ;
33739 0 : inFile.read ( (char*) (storageArraySgIncludeNextDirectiveStatement) , sizeof ( SgIncludeNextDirectiveStatementStorageClass ) * sizeOfActualPool) ;
33740 0 : SgIncludeNextDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33741 : SgIncludeNextDirectiveStatementStorageClass* storageArray = storageArraySgIncludeNextDirectiveStatement;
33742 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33743 : {
33744 0 : SgIncludeNextDirectiveStatement* tmp = new SgIncludeNextDirectiveStatement ( *storageArray ) ;
33745 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33746 0 : storageArray++ ;
33747 : }
33748 : }
33749 0 : delete [] storageArraySgIncludeNextDirectiveStatement;
33750 2 : SgIncludeNextDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33751 :
33752 :
33753 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInitializedName );
33754 2 : SgInitializedNameStorageClass* storageArraySgInitializedName = NULL;
33755 2 : if ( 0 < sizeOfActualPool )
33756 : {
33757 55227 : storageArraySgInitializedName = new SgInitializedNameStorageClass[sizeOfActualPool] ;
33758 2 : inFile.read ( (char*) (storageArraySgInitializedName) , sizeof ( SgInitializedNameStorageClass ) * sizeOfActualPool) ;
33759 2 : SgInitializedNameStorageClass :: readEasyStorageDataFromFile(inFile) ;
33760 : SgInitializedNameStorageClass* storageArray = storageArraySgInitializedName;
33761 55227 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33762 : {
33763 55225 : SgInitializedName* tmp = new SgInitializedName ( *storageArray ) ;
33764 55225 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33765 55225 : storageArray++ ;
33766 : }
33767 : }
33768 2 : delete [] storageArraySgInitializedName;
33769 2 : SgInitializedNameStorageClass :: deleteStaticDataOfEasyStorageClasses();
33770 :
33771 :
33772 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInitializer );
33773 2 : SgInitializerStorageClass* storageArraySgInitializer = NULL;
33774 2 : if ( 0 < sizeOfActualPool )
33775 : {
33776 0 : storageArraySgInitializer = new SgInitializerStorageClass[sizeOfActualPool] ;
33777 0 : inFile.read ( (char*) (storageArraySgInitializer) , sizeof ( SgInitializerStorageClass ) * sizeOfActualPool) ;
33778 0 : SgInitializerStorageClass :: readEasyStorageDataFromFile(inFile) ;
33779 : SgInitializerStorageClass* storageArray = storageArraySgInitializer;
33780 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33781 : {
33782 0 : SgInitializer* tmp = new SgInitializer ( *storageArray ) ;
33783 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33784 0 : storageArray++ ;
33785 : }
33786 : }
33787 0 : delete [] storageArraySgInitializer;
33788 2 : SgInitializerStorageClass :: deleteStaticDataOfEasyStorageClasses();
33789 :
33790 :
33791 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInquireStatement );
33792 2 : SgInquireStatementStorageClass* storageArraySgInquireStatement = NULL;
33793 2 : if ( 0 < sizeOfActualPool )
33794 : {
33795 0 : storageArraySgInquireStatement = new SgInquireStatementStorageClass[sizeOfActualPool] ;
33796 0 : inFile.read ( (char*) (storageArraySgInquireStatement) , sizeof ( SgInquireStatementStorageClass ) * sizeOfActualPool) ;
33797 0 : SgInquireStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33798 : SgInquireStatementStorageClass* storageArray = storageArraySgInquireStatement;
33799 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33800 : {
33801 0 : SgInquireStatement* tmp = new SgInquireStatement ( *storageArray ) ;
33802 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33803 0 : storageArray++ ;
33804 : }
33805 : }
33806 0 : delete [] storageArraySgInquireStatement;
33807 2 : SgInquireStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33808 :
33809 :
33810 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIntKeyedBidirectionalGraph );
33811 2 : SgIntKeyedBidirectionalGraphStorageClass* storageArraySgIntKeyedBidirectionalGraph = NULL;
33812 2 : if ( 0 < sizeOfActualPool )
33813 : {
33814 0 : storageArraySgIntKeyedBidirectionalGraph = new SgIntKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
33815 0 : inFile.read ( (char*) (storageArraySgIntKeyedBidirectionalGraph) , sizeof ( SgIntKeyedBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
33816 0 : SgIntKeyedBidirectionalGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
33817 : SgIntKeyedBidirectionalGraphStorageClass* storageArray = storageArraySgIntKeyedBidirectionalGraph;
33818 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33819 : {
33820 0 : SgIntKeyedBidirectionalGraph* tmp = new SgIntKeyedBidirectionalGraph ( *storageArray ) ;
33821 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33822 0 : storageArray++ ;
33823 : }
33824 : }
33825 0 : delete [] storageArraySgIntKeyedBidirectionalGraph;
33826 2 : SgIntKeyedBidirectionalGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
33827 :
33828 :
33829 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIntVal );
33830 2 : SgIntValStorageClass* storageArraySgIntVal = NULL;
33831 2 : if ( 0 < sizeOfActualPool )
33832 : {
33833 927 : storageArraySgIntVal = new SgIntValStorageClass[sizeOfActualPool] ;
33834 2 : inFile.read ( (char*) (storageArraySgIntVal) , sizeof ( SgIntValStorageClass ) * sizeOfActualPool) ;
33835 2 : SgIntValStorageClass :: readEasyStorageDataFromFile(inFile) ;
33836 : SgIntValStorageClass* storageArray = storageArraySgIntVal;
33837 927 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33838 : {
33839 925 : SgIntVal* tmp = new SgIntVal ( *storageArray ) ;
33840 925 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33841 925 : storageArray++ ;
33842 : }
33843 : }
33844 2 : delete [] storageArraySgIntVal;
33845 2 : SgIntValStorageClass :: deleteStaticDataOfEasyStorageClasses();
33846 :
33847 :
33848 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIntegerDivideOp );
33849 2 : SgIntegerDivideOpStorageClass* storageArraySgIntegerDivideOp = NULL;
33850 2 : if ( 0 < sizeOfActualPool )
33851 : {
33852 0 : storageArraySgIntegerDivideOp = new SgIntegerDivideOpStorageClass[sizeOfActualPool] ;
33853 0 : inFile.read ( (char*) (storageArraySgIntegerDivideOp) , sizeof ( SgIntegerDivideOpStorageClass ) * sizeOfActualPool) ;
33854 0 : SgIntegerDivideOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33855 : SgIntegerDivideOpStorageClass* storageArray = storageArraySgIntegerDivideOp;
33856 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33857 : {
33858 0 : SgIntegerDivideOp* tmp = new SgIntegerDivideOp ( *storageArray ) ;
33859 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33860 0 : storageArray++ ;
33861 : }
33862 : }
33863 0 : delete [] storageArraySgIntegerDivideOp;
33864 2 : SgIntegerDivideOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33865 :
33866 :
33867 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIntegerDivideAssignOp );
33868 2 : SgIntegerDivideAssignOpStorageClass* storageArraySgIntegerDivideAssignOp = NULL;
33869 2 : if ( 0 < sizeOfActualPool )
33870 : {
33871 0 : storageArraySgIntegerDivideAssignOp = new SgIntegerDivideAssignOpStorageClass[sizeOfActualPool] ;
33872 0 : inFile.read ( (char*) (storageArraySgIntegerDivideAssignOp) , sizeof ( SgIntegerDivideAssignOpStorageClass ) * sizeOfActualPool) ;
33873 0 : SgIntegerDivideAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
33874 : SgIntegerDivideAssignOpStorageClass* storageArray = storageArraySgIntegerDivideAssignOp;
33875 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33876 : {
33877 0 : SgIntegerDivideAssignOp* tmp = new SgIntegerDivideAssignOp ( *storageArray ) ;
33878 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33879 0 : storageArray++ ;
33880 : }
33881 : }
33882 0 : delete [] storageArraySgIntegerDivideAssignOp;
33883 2 : SgIntegerDivideAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
33884 :
33885 :
33886 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInterfaceBody );
33887 2 : SgInterfaceBodyStorageClass* storageArraySgInterfaceBody = NULL;
33888 2 : if ( 0 < sizeOfActualPool )
33889 : {
33890 0 : storageArraySgInterfaceBody = new SgInterfaceBodyStorageClass[sizeOfActualPool] ;
33891 0 : inFile.read ( (char*) (storageArraySgInterfaceBody) , sizeof ( SgInterfaceBodyStorageClass ) * sizeOfActualPool) ;
33892 0 : SgInterfaceBodyStorageClass :: readEasyStorageDataFromFile(inFile) ;
33893 : SgInterfaceBodyStorageClass* storageArray = storageArraySgInterfaceBody;
33894 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33895 : {
33896 0 : SgInterfaceBody* tmp = new SgInterfaceBody ( *storageArray ) ;
33897 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33898 0 : storageArray++ ;
33899 : }
33900 : }
33901 0 : delete [] storageArraySgInterfaceBody;
33902 2 : SgInterfaceBodyStorageClass :: deleteStaticDataOfEasyStorageClasses();
33903 :
33904 :
33905 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgHeaderFileBody );
33906 2 : SgHeaderFileBodyStorageClass* storageArraySgHeaderFileBody = NULL;
33907 2 : if ( 0 < sizeOfActualPool )
33908 : {
33909 0 : storageArraySgHeaderFileBody = new SgHeaderFileBodyStorageClass[sizeOfActualPool] ;
33910 0 : inFile.read ( (char*) (storageArraySgHeaderFileBody) , sizeof ( SgHeaderFileBodyStorageClass ) * sizeOfActualPool) ;
33911 0 : SgHeaderFileBodyStorageClass :: readEasyStorageDataFromFile(inFile) ;
33912 : SgHeaderFileBodyStorageClass* storageArray = storageArraySgHeaderFileBody;
33913 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33914 : {
33915 0 : SgHeaderFileBody* tmp = new SgHeaderFileBody ( *storageArray ) ;
33916 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33917 0 : storageArray++ ;
33918 : }
33919 : }
33920 0 : delete [] storageArraySgHeaderFileBody;
33921 2 : SgHeaderFileBodyStorageClass :: deleteStaticDataOfEasyStorageClasses();
33922 :
33923 :
33924 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgHeaderFileReport );
33925 2 : SgHeaderFileReportStorageClass* storageArraySgHeaderFileReport = NULL;
33926 2 : if ( 0 < sizeOfActualPool )
33927 : {
33928 0 : storageArraySgHeaderFileReport = new SgHeaderFileReportStorageClass[sizeOfActualPool] ;
33929 0 : inFile.read ( (char*) (storageArraySgHeaderFileReport) , sizeof ( SgHeaderFileReportStorageClass ) * sizeOfActualPool) ;
33930 0 : SgHeaderFileReportStorageClass :: readEasyStorageDataFromFile(inFile) ;
33931 : SgHeaderFileReportStorageClass* storageArray = storageArraySgHeaderFileReport;
33932 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33933 : {
33934 0 : SgHeaderFileReport* tmp = new SgHeaderFileReport ( *storageArray ) ;
33935 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33936 0 : storageArray++ ;
33937 : }
33938 : }
33939 0 : delete [] storageArraySgHeaderFileReport;
33940 2 : SgHeaderFileReportStorageClass :: deleteStaticDataOfEasyStorageClasses();
33941 :
33942 :
33943 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInterfaceStatement );
33944 2 : SgInterfaceStatementStorageClass* storageArraySgInterfaceStatement = NULL;
33945 2 : if ( 0 < sizeOfActualPool )
33946 : {
33947 0 : storageArraySgInterfaceStatement = new SgInterfaceStatementStorageClass[sizeOfActualPool] ;
33948 0 : inFile.read ( (char*) (storageArraySgInterfaceStatement) , sizeof ( SgInterfaceStatementStorageClass ) * sizeOfActualPool) ;
33949 0 : SgInterfaceStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
33950 : SgInterfaceStatementStorageClass* storageArray = storageArraySgInterfaceStatement;
33951 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33952 : {
33953 0 : SgInterfaceStatement* tmp = new SgInterfaceStatement ( *storageArray ) ;
33954 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33955 0 : storageArray++ ;
33956 : }
33957 : }
33958 0 : delete [] storageArraySgInterfaceStatement;
33959 2 : SgInterfaceStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
33960 :
33961 :
33962 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgInterfaceSymbol );
33963 2 : SgInterfaceSymbolStorageClass* storageArraySgInterfaceSymbol = NULL;
33964 2 : if ( 0 < sizeOfActualPool )
33965 : {
33966 0 : storageArraySgInterfaceSymbol = new SgInterfaceSymbolStorageClass[sizeOfActualPool] ;
33967 0 : inFile.read ( (char*) (storageArraySgInterfaceSymbol) , sizeof ( SgInterfaceSymbolStorageClass ) * sizeOfActualPool) ;
33968 0 : SgInterfaceSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
33969 : SgInterfaceSymbolStorageClass* storageArray = storageArraySgInterfaceSymbol;
33970 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33971 : {
33972 0 : SgInterfaceSymbol* tmp = new SgInterfaceSymbol ( *storageArray ) ;
33973 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33974 0 : storageArray++ ;
33975 : }
33976 : }
33977 0 : delete [] storageArraySgInterfaceSymbol;
33978 2 : SgInterfaceSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
33979 :
33980 :
33981 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIntrinsicSymbol );
33982 2 : SgIntrinsicSymbolStorageClass* storageArraySgIntrinsicSymbol = NULL;
33983 2 : if ( 0 < sizeOfActualPool )
33984 : {
33985 0 : storageArraySgIntrinsicSymbol = new SgIntrinsicSymbolStorageClass[sizeOfActualPool] ;
33986 0 : inFile.read ( (char*) (storageArraySgIntrinsicSymbol) , sizeof ( SgIntrinsicSymbolStorageClass ) * sizeOfActualPool) ;
33987 0 : SgIntrinsicSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
33988 : SgIntrinsicSymbolStorageClass* storageArray = storageArraySgIntrinsicSymbol;
33989 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
33990 : {
33991 0 : SgIntrinsicSymbol* tmp = new SgIntrinsicSymbol ( *storageArray ) ;
33992 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
33993 0 : storageArray++ ;
33994 : }
33995 : }
33996 0 : delete [] storageArraySgIntrinsicSymbol;
33997 2 : SgIntrinsicSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
33998 :
33999 :
34000 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIsOp );
34001 2 : SgIsOpStorageClass* storageArraySgIsOp = NULL;
34002 2 : if ( 0 < sizeOfActualPool )
34003 : {
34004 0 : storageArraySgIsOp = new SgIsOpStorageClass[sizeOfActualPool] ;
34005 0 : inFile.read ( (char*) (storageArraySgIsOp) , sizeof ( SgIsOpStorageClass ) * sizeOfActualPool) ;
34006 0 : SgIsOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34007 : SgIsOpStorageClass* storageArray = storageArraySgIsOp;
34008 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34009 : {
34010 0 : SgIsOp* tmp = new SgIsOp ( *storageArray ) ;
34011 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34012 0 : storageArray++ ;
34013 : }
34014 : }
34015 0 : delete [] storageArraySgIsOp;
34016 2 : SgIsOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34017 :
34018 :
34019 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIsNotOp );
34020 2 : SgIsNotOpStorageClass* storageArraySgIsNotOp = NULL;
34021 2 : if ( 0 < sizeOfActualPool )
34022 : {
34023 0 : storageArraySgIsNotOp = new SgIsNotOpStorageClass[sizeOfActualPool] ;
34024 0 : inFile.read ( (char*) (storageArraySgIsNotOp) , sizeof ( SgIsNotOpStorageClass ) * sizeOfActualPool) ;
34025 0 : SgIsNotOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34026 : SgIsNotOpStorageClass* storageArray = storageArraySgIsNotOp;
34027 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34028 : {
34029 0 : SgIsNotOp* tmp = new SgIsNotOp ( *storageArray ) ;
34030 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34031 0 : storageArray++ ;
34032 : }
34033 : }
34034 0 : delete [] storageArraySgIsNotOp;
34035 2 : SgIsNotOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34036 :
34037 :
34038 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgIorAssignOp );
34039 2 : SgIorAssignOpStorageClass* storageArraySgIorAssignOp = NULL;
34040 2 : if ( 0 < sizeOfActualPool )
34041 : {
34042 8 : storageArraySgIorAssignOp = new SgIorAssignOpStorageClass[sizeOfActualPool] ;
34043 1 : inFile.read ( (char*) (storageArraySgIorAssignOp) , sizeof ( SgIorAssignOpStorageClass ) * sizeOfActualPool) ;
34044 1 : SgIorAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34045 : SgIorAssignOpStorageClass* storageArray = storageArraySgIorAssignOp;
34046 8 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34047 : {
34048 7 : SgIorAssignOp* tmp = new SgIorAssignOp ( *storageArray ) ;
34049 7 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34050 7 : storageArray++ ;
34051 : }
34052 : }
34053 1 : delete [] storageArraySgIorAssignOp;
34054 2 : SgIorAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34055 :
34056 :
34057 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgKeyDatumPair );
34058 2 : SgKeyDatumPairStorageClass* storageArraySgKeyDatumPair = NULL;
34059 2 : if ( 0 < sizeOfActualPool )
34060 : {
34061 0 : storageArraySgKeyDatumPair = new SgKeyDatumPairStorageClass[sizeOfActualPool] ;
34062 0 : inFile.read ( (char*) (storageArraySgKeyDatumPair) , sizeof ( SgKeyDatumPairStorageClass ) * sizeOfActualPool) ;
34063 0 : SgKeyDatumPairStorageClass :: readEasyStorageDataFromFile(inFile) ;
34064 : SgKeyDatumPairStorageClass* storageArray = storageArraySgKeyDatumPair;
34065 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34066 : {
34067 0 : SgKeyDatumPair* tmp = new SgKeyDatumPair ( *storageArray ) ;
34068 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34069 0 : storageArray++ ;
34070 : }
34071 : }
34072 0 : delete [] storageArraySgKeyDatumPair;
34073 2 : SgKeyDatumPairStorageClass :: deleteStaticDataOfEasyStorageClasses();
34074 :
34075 :
34076 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCudaKernelExecConfig );
34077 2 : SgCudaKernelExecConfigStorageClass* storageArraySgCudaKernelExecConfig = NULL;
34078 2 : if ( 0 < sizeOfActualPool )
34079 : {
34080 0 : storageArraySgCudaKernelExecConfig = new SgCudaKernelExecConfigStorageClass[sizeOfActualPool] ;
34081 0 : inFile.read ( (char*) (storageArraySgCudaKernelExecConfig) , sizeof ( SgCudaKernelExecConfigStorageClass ) * sizeOfActualPool) ;
34082 0 : SgCudaKernelExecConfigStorageClass :: readEasyStorageDataFromFile(inFile) ;
34083 : SgCudaKernelExecConfigStorageClass* storageArray = storageArraySgCudaKernelExecConfig;
34084 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34085 : {
34086 0 : SgCudaKernelExecConfig* tmp = new SgCudaKernelExecConfig ( *storageArray ) ;
34087 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34088 0 : storageArray++ ;
34089 : }
34090 : }
34091 0 : delete [] storageArraySgCudaKernelExecConfig;
34092 2 : SgCudaKernelExecConfigStorageClass :: deleteStaticDataOfEasyStorageClasses();
34093 :
34094 :
34095 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCudaKernelCallExp );
34096 2 : SgCudaKernelCallExpStorageClass* storageArraySgCudaKernelCallExp = NULL;
34097 2 : if ( 0 < sizeOfActualPool )
34098 : {
34099 0 : storageArraySgCudaKernelCallExp = new SgCudaKernelCallExpStorageClass[sizeOfActualPool] ;
34100 0 : inFile.read ( (char*) (storageArraySgCudaKernelCallExp) , sizeof ( SgCudaKernelCallExpStorageClass ) * sizeOfActualPool) ;
34101 0 : SgCudaKernelCallExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34102 : SgCudaKernelCallExpStorageClass* storageArray = storageArraySgCudaKernelCallExp;
34103 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34104 : {
34105 0 : SgCudaKernelCallExp* tmp = new SgCudaKernelCallExp ( *storageArray ) ;
34106 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34107 0 : storageArray++ ;
34108 : }
34109 : }
34110 0 : delete [] storageArraySgCudaKernelCallExp;
34111 2 : SgCudaKernelCallExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34112 :
34113 :
34114 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLabelRefExp );
34115 2 : SgLabelRefExpStorageClass* storageArraySgLabelRefExp = NULL;
34116 2 : if ( 0 < sizeOfActualPool )
34117 : {
34118 0 : storageArraySgLabelRefExp = new SgLabelRefExpStorageClass[sizeOfActualPool] ;
34119 0 : inFile.read ( (char*) (storageArraySgLabelRefExp) , sizeof ( SgLabelRefExpStorageClass ) * sizeOfActualPool) ;
34120 0 : SgLabelRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34121 : SgLabelRefExpStorageClass* storageArray = storageArraySgLabelRefExp;
34122 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34123 : {
34124 0 : SgLabelRefExp* tmp = new SgLabelRefExp ( *storageArray ) ;
34125 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34126 0 : storageArray++ ;
34127 : }
34128 : }
34129 0 : delete [] storageArraySgLabelRefExp;
34130 2 : SgLabelRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34131 :
34132 :
34133 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLabelStatement );
34134 2 : SgLabelStatementStorageClass* storageArraySgLabelStatement = NULL;
34135 2 : if ( 0 < sizeOfActualPool )
34136 : {
34137 0 : storageArraySgLabelStatement = new SgLabelStatementStorageClass[sizeOfActualPool] ;
34138 0 : inFile.read ( (char*) (storageArraySgLabelStatement) , sizeof ( SgLabelStatementStorageClass ) * sizeOfActualPool) ;
34139 0 : SgLabelStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
34140 : SgLabelStatementStorageClass* storageArray = storageArraySgLabelStatement;
34141 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34142 : {
34143 0 : SgLabelStatement* tmp = new SgLabelStatement ( *storageArray ) ;
34144 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34145 0 : storageArray++ ;
34146 : }
34147 : }
34148 0 : delete [] storageArraySgLabelStatement;
34149 2 : SgLabelStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
34150 :
34151 :
34152 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLabelSymbol );
34153 2 : SgLabelSymbolStorageClass* storageArraySgLabelSymbol = NULL;
34154 2 : if ( 0 < sizeOfActualPool )
34155 : {
34156 0 : storageArraySgLabelSymbol = new SgLabelSymbolStorageClass[sizeOfActualPool] ;
34157 0 : inFile.read ( (char*) (storageArraySgLabelSymbol) , sizeof ( SgLabelSymbolStorageClass ) * sizeOfActualPool) ;
34158 0 : SgLabelSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
34159 : SgLabelSymbolStorageClass* storageArray = storageArraySgLabelSymbol;
34160 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34161 : {
34162 0 : SgLabelSymbol* tmp = new SgLabelSymbol ( *storageArray ) ;
34163 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34164 0 : storageArray++ ;
34165 : }
34166 : }
34167 0 : delete [] storageArraySgLabelSymbol;
34168 2 : SgLabelSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
34169 :
34170 :
34171 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLambdaCapture );
34172 2 : SgLambdaCaptureStorageClass* storageArraySgLambdaCapture = NULL;
34173 2 : if ( 0 < sizeOfActualPool )
34174 : {
34175 0 : storageArraySgLambdaCapture = new SgLambdaCaptureStorageClass[sizeOfActualPool] ;
34176 0 : inFile.read ( (char*) (storageArraySgLambdaCapture) , sizeof ( SgLambdaCaptureStorageClass ) * sizeOfActualPool) ;
34177 0 : SgLambdaCaptureStorageClass :: readEasyStorageDataFromFile(inFile) ;
34178 : SgLambdaCaptureStorageClass* storageArray = storageArraySgLambdaCapture;
34179 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34180 : {
34181 0 : SgLambdaCapture* tmp = new SgLambdaCapture ( *storageArray ) ;
34182 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34183 0 : storageArray++ ;
34184 : }
34185 : }
34186 0 : delete [] storageArraySgLambdaCapture;
34187 2 : SgLambdaCaptureStorageClass :: deleteStaticDataOfEasyStorageClasses();
34188 :
34189 :
34190 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLambdaCaptureList );
34191 2 : SgLambdaCaptureListStorageClass* storageArraySgLambdaCaptureList = NULL;
34192 2 : if ( 0 < sizeOfActualPool )
34193 : {
34194 0 : storageArraySgLambdaCaptureList = new SgLambdaCaptureListStorageClass[sizeOfActualPool] ;
34195 0 : inFile.read ( (char*) (storageArraySgLambdaCaptureList) , sizeof ( SgLambdaCaptureListStorageClass ) * sizeOfActualPool) ;
34196 0 : SgLambdaCaptureListStorageClass :: readEasyStorageDataFromFile(inFile) ;
34197 : SgLambdaCaptureListStorageClass* storageArray = storageArraySgLambdaCaptureList;
34198 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34199 : {
34200 0 : SgLambdaCaptureList* tmp = new SgLambdaCaptureList ( *storageArray ) ;
34201 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34202 0 : storageArray++ ;
34203 : }
34204 : }
34205 0 : delete [] storageArraySgLambdaCaptureList;
34206 2 : SgLambdaCaptureListStorageClass :: deleteStaticDataOfEasyStorageClasses();
34207 :
34208 :
34209 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLambdaExp );
34210 2 : SgLambdaExpStorageClass* storageArraySgLambdaExp = NULL;
34211 2 : if ( 0 < sizeOfActualPool )
34212 : {
34213 0 : storageArraySgLambdaExp = new SgLambdaExpStorageClass[sizeOfActualPool] ;
34214 0 : inFile.read ( (char*) (storageArraySgLambdaExp) , sizeof ( SgLambdaExpStorageClass ) * sizeOfActualPool) ;
34215 0 : SgLambdaExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34216 : SgLambdaExpStorageClass* storageArray = storageArraySgLambdaExp;
34217 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34218 : {
34219 0 : SgLambdaExp* tmp = new SgLambdaExp ( *storageArray ) ;
34220 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34221 0 : storageArray++ ;
34222 : }
34223 : }
34224 0 : delete [] storageArraySgLambdaExp;
34225 2 : SgLambdaExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34226 :
34227 :
34228 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLambdaRefExp );
34229 2 : SgLambdaRefExpStorageClass* storageArraySgLambdaRefExp = NULL;
34230 2 : if ( 0 < sizeOfActualPool )
34231 : {
34232 0 : storageArraySgLambdaRefExp = new SgLambdaRefExpStorageClass[sizeOfActualPool] ;
34233 0 : inFile.read ( (char*) (storageArraySgLambdaRefExp) , sizeof ( SgLambdaRefExpStorageClass ) * sizeOfActualPool) ;
34234 0 : SgLambdaRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34235 : SgLambdaRefExpStorageClass* storageArray = storageArraySgLambdaRefExp;
34236 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34237 : {
34238 0 : SgLambdaRefExp* tmp = new SgLambdaRefExp ( *storageArray ) ;
34239 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34240 0 : storageArray++ ;
34241 : }
34242 : }
34243 0 : delete [] storageArraySgLambdaRefExp;
34244 2 : SgLambdaRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34245 :
34246 :
34247 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLeftDivideOp );
34248 2 : SgLeftDivideOpStorageClass* storageArraySgLeftDivideOp = NULL;
34249 2 : if ( 0 < sizeOfActualPool )
34250 : {
34251 0 : storageArraySgLeftDivideOp = new SgLeftDivideOpStorageClass[sizeOfActualPool] ;
34252 0 : inFile.read ( (char*) (storageArraySgLeftDivideOp) , sizeof ( SgLeftDivideOpStorageClass ) * sizeOfActualPool) ;
34253 0 : SgLeftDivideOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34254 : SgLeftDivideOpStorageClass* storageArray = storageArraySgLeftDivideOp;
34255 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34256 : {
34257 0 : SgLeftDivideOp* tmp = new SgLeftDivideOp ( *storageArray ) ;
34258 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34259 0 : storageArray++ ;
34260 : }
34261 : }
34262 0 : delete [] storageArraySgLeftDivideOp;
34263 2 : SgLeftDivideOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34264 :
34265 :
34266 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLessOrEqualOp );
34267 2 : SgLessOrEqualOpStorageClass* storageArraySgLessOrEqualOp = NULL;
34268 2 : if ( 0 < sizeOfActualPool )
34269 : {
34270 32 : storageArraySgLessOrEqualOp = new SgLessOrEqualOpStorageClass[sizeOfActualPool] ;
34271 1 : inFile.read ( (char*) (storageArraySgLessOrEqualOp) , sizeof ( SgLessOrEqualOpStorageClass ) * sizeOfActualPool) ;
34272 1 : SgLessOrEqualOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34273 : SgLessOrEqualOpStorageClass* storageArray = storageArraySgLessOrEqualOp;
34274 32 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34275 : {
34276 31 : SgLessOrEqualOp* tmp = new SgLessOrEqualOp ( *storageArray ) ;
34277 31 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34278 31 : storageArray++ ;
34279 : }
34280 : }
34281 1 : delete [] storageArraySgLessOrEqualOp;
34282 2 : SgLessOrEqualOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34283 :
34284 :
34285 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLessThanOp );
34286 2 : SgLessThanOpStorageClass* storageArraySgLessThanOp = NULL;
34287 2 : if ( 0 < sizeOfActualPool )
34288 : {
34289 137 : storageArraySgLessThanOp = new SgLessThanOpStorageClass[sizeOfActualPool] ;
34290 1 : inFile.read ( (char*) (storageArraySgLessThanOp) , sizeof ( SgLessThanOpStorageClass ) * sizeOfActualPool) ;
34291 1 : SgLessThanOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34292 : SgLessThanOpStorageClass* storageArray = storageArraySgLessThanOp;
34293 137 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34294 : {
34295 136 : SgLessThanOp* tmp = new SgLessThanOp ( *storageArray ) ;
34296 136 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34297 136 : storageArray++ ;
34298 : }
34299 : }
34300 1 : delete [] storageArraySgLessThanOp;
34301 2 : SgLessThanOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34302 :
34303 :
34304 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLineDirectiveStatement );
34305 2 : SgLineDirectiveStatementStorageClass* storageArraySgLineDirectiveStatement = NULL;
34306 2 : if ( 0 < sizeOfActualPool )
34307 : {
34308 0 : storageArraySgLineDirectiveStatement = new SgLineDirectiveStatementStorageClass[sizeOfActualPool] ;
34309 0 : inFile.read ( (char*) (storageArraySgLineDirectiveStatement) , sizeof ( SgLineDirectiveStatementStorageClass ) * sizeOfActualPool) ;
34310 0 : SgLineDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
34311 : SgLineDirectiveStatementStorageClass* storageArray = storageArraySgLineDirectiveStatement;
34312 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34313 : {
34314 0 : SgLineDirectiveStatement* tmp = new SgLineDirectiveStatement ( *storageArray ) ;
34315 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34316 0 : storageArray++ ;
34317 : }
34318 : }
34319 0 : delete [] storageArraySgLineDirectiveStatement;
34320 2 : SgLineDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
34321 :
34322 :
34323 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLinemarkerDirectiveStatement );
34324 2 : SgLinemarkerDirectiveStatementStorageClass* storageArraySgLinemarkerDirectiveStatement = NULL;
34325 2 : if ( 0 < sizeOfActualPool )
34326 : {
34327 0 : storageArraySgLinemarkerDirectiveStatement = new SgLinemarkerDirectiveStatementStorageClass[sizeOfActualPool] ;
34328 0 : inFile.read ( (char*) (storageArraySgLinemarkerDirectiveStatement) , sizeof ( SgLinemarkerDirectiveStatementStorageClass ) * sizeOfActualPool) ;
34329 0 : SgLinemarkerDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
34330 : SgLinemarkerDirectiveStatementStorageClass* storageArray = storageArraySgLinemarkerDirectiveStatement;
34331 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34332 : {
34333 0 : SgLinemarkerDirectiveStatement* tmp = new SgLinemarkerDirectiveStatement ( *storageArray ) ;
34334 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34335 0 : storageArray++ ;
34336 : }
34337 : }
34338 0 : delete [] storageArraySgLinemarkerDirectiveStatement;
34339 2 : SgLinemarkerDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
34340 :
34341 :
34342 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLinkageModifier );
34343 2 : SgLinkageModifierStorageClass* storageArraySgLinkageModifier = NULL;
34344 2 : if ( 0 < sizeOfActualPool )
34345 : {
34346 0 : storageArraySgLinkageModifier = new SgLinkageModifierStorageClass[sizeOfActualPool] ;
34347 0 : inFile.read ( (char*) (storageArraySgLinkageModifier) , sizeof ( SgLinkageModifierStorageClass ) * sizeOfActualPool) ;
34348 : SgLinkageModifierStorageClass* storageArray = storageArraySgLinkageModifier;
34349 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34350 : {
34351 0 : SgLinkageModifier* tmp = new SgLinkageModifier ( *storageArray ) ;
34352 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34353 0 : storageArray++ ;
34354 : }
34355 : }
34356 0 : delete [] storageArraySgLinkageModifier;
34357 :
34358 :
34359 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgListComprehension );
34360 2 : SgListComprehensionStorageClass* storageArraySgListComprehension = NULL;
34361 2 : if ( 0 < sizeOfActualPool )
34362 : {
34363 0 : storageArraySgListComprehension = new SgListComprehensionStorageClass[sizeOfActualPool] ;
34364 0 : inFile.read ( (char*) (storageArraySgListComprehension) , sizeof ( SgListComprehensionStorageClass ) * sizeOfActualPool) ;
34365 0 : SgListComprehensionStorageClass :: readEasyStorageDataFromFile(inFile) ;
34366 : SgListComprehensionStorageClass* storageArray = storageArraySgListComprehension;
34367 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34368 : {
34369 0 : SgListComprehension* tmp = new SgListComprehension ( *storageArray ) ;
34370 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34371 0 : storageArray++ ;
34372 : }
34373 : }
34374 0 : delete [] storageArraySgListComprehension;
34375 2 : SgListComprehensionStorageClass :: deleteStaticDataOfEasyStorageClasses();
34376 :
34377 :
34378 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgListExp );
34379 2 : SgListExpStorageClass* storageArraySgListExp = NULL;
34380 2 : if ( 0 < sizeOfActualPool )
34381 : {
34382 0 : storageArraySgListExp = new SgListExpStorageClass[sizeOfActualPool] ;
34383 0 : inFile.read ( (char*) (storageArraySgListExp) , sizeof ( SgListExpStorageClass ) * sizeOfActualPool) ;
34384 0 : SgListExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34385 : SgListExpStorageClass* storageArray = storageArraySgListExp;
34386 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34387 : {
34388 0 : SgListExp* tmp = new SgListExp ( *storageArray ) ;
34389 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34390 0 : storageArray++ ;
34391 : }
34392 : }
34393 0 : delete [] storageArraySgListExp;
34394 2 : SgListExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34395 :
34396 :
34397 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLocatedNode );
34398 2 : SgLocatedNodeStorageClass* storageArraySgLocatedNode = NULL;
34399 2 : if ( 0 < sizeOfActualPool )
34400 : {
34401 0 : storageArraySgLocatedNode = new SgLocatedNodeStorageClass[sizeOfActualPool] ;
34402 0 : inFile.read ( (char*) (storageArraySgLocatedNode) , sizeof ( SgLocatedNodeStorageClass ) * sizeOfActualPool) ;
34403 0 : SgLocatedNodeStorageClass :: readEasyStorageDataFromFile(inFile) ;
34404 : SgLocatedNodeStorageClass* storageArray = storageArraySgLocatedNode;
34405 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34406 : {
34407 0 : SgLocatedNode* tmp = new SgLocatedNode ( *storageArray ) ;
34408 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34409 0 : storageArray++ ;
34410 : }
34411 : }
34412 0 : delete [] storageArraySgLocatedNode;
34413 2 : SgLocatedNodeStorageClass :: deleteStaticDataOfEasyStorageClasses();
34414 :
34415 :
34416 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLocatedNodeSupport );
34417 2 : SgLocatedNodeSupportStorageClass* storageArraySgLocatedNodeSupport = NULL;
34418 2 : if ( 0 < sizeOfActualPool )
34419 : {
34420 0 : storageArraySgLocatedNodeSupport = new SgLocatedNodeSupportStorageClass[sizeOfActualPool] ;
34421 0 : inFile.read ( (char*) (storageArraySgLocatedNodeSupport) , sizeof ( SgLocatedNodeSupportStorageClass ) * sizeOfActualPool) ;
34422 0 : SgLocatedNodeSupportStorageClass :: readEasyStorageDataFromFile(inFile) ;
34423 : SgLocatedNodeSupportStorageClass* storageArray = storageArraySgLocatedNodeSupport;
34424 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34425 : {
34426 0 : SgLocatedNodeSupport* tmp = new SgLocatedNodeSupport ( *storageArray ) ;
34427 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34428 0 : storageArray++ ;
34429 : }
34430 : }
34431 0 : delete [] storageArraySgLocatedNodeSupport;
34432 2 : SgLocatedNodeSupportStorageClass :: deleteStaticDataOfEasyStorageClasses();
34433 :
34434 :
34435 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLongDoubleVal );
34436 2 : SgLongDoubleValStorageClass* storageArraySgLongDoubleVal = NULL;
34437 2 : if ( 0 < sizeOfActualPool )
34438 : {
34439 0 : storageArraySgLongDoubleVal = new SgLongDoubleValStorageClass[sizeOfActualPool] ;
34440 0 : inFile.read ( (char*) (storageArraySgLongDoubleVal) , sizeof ( SgLongDoubleValStorageClass ) * sizeOfActualPool) ;
34441 0 : SgLongDoubleValStorageClass :: readEasyStorageDataFromFile(inFile) ;
34442 : SgLongDoubleValStorageClass* storageArray = storageArraySgLongDoubleVal;
34443 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34444 : {
34445 0 : SgLongDoubleVal* tmp = new SgLongDoubleVal ( *storageArray ) ;
34446 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34447 0 : storageArray++ ;
34448 : }
34449 : }
34450 0 : delete [] storageArraySgLongDoubleVal;
34451 2 : SgLongDoubleValStorageClass :: deleteStaticDataOfEasyStorageClasses();
34452 :
34453 :
34454 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLongIntVal );
34455 2 : SgLongIntValStorageClass* storageArraySgLongIntVal = NULL;
34456 2 : if ( 0 < sizeOfActualPool )
34457 : {
34458 14 : storageArraySgLongIntVal = new SgLongIntValStorageClass[sizeOfActualPool] ;
34459 1 : inFile.read ( (char*) (storageArraySgLongIntVal) , sizeof ( SgLongIntValStorageClass ) * sizeOfActualPool) ;
34460 1 : SgLongIntValStorageClass :: readEasyStorageDataFromFile(inFile) ;
34461 : SgLongIntValStorageClass* storageArray = storageArraySgLongIntVal;
34462 14 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34463 : {
34464 13 : SgLongIntVal* tmp = new SgLongIntVal ( *storageArray ) ;
34465 13 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34466 13 : storageArray++ ;
34467 : }
34468 : }
34469 1 : delete [] storageArraySgLongIntVal;
34470 2 : SgLongIntValStorageClass :: deleteStaticDataOfEasyStorageClasses();
34471 :
34472 :
34473 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLongLongIntVal );
34474 2 : SgLongLongIntValStorageClass* storageArraySgLongLongIntVal = NULL;
34475 2 : if ( 0 < sizeOfActualPool )
34476 : {
34477 0 : storageArraySgLongLongIntVal = new SgLongLongIntValStorageClass[sizeOfActualPool] ;
34478 0 : inFile.read ( (char*) (storageArraySgLongLongIntVal) , sizeof ( SgLongLongIntValStorageClass ) * sizeOfActualPool) ;
34479 0 : SgLongLongIntValStorageClass :: readEasyStorageDataFromFile(inFile) ;
34480 : SgLongLongIntValStorageClass* storageArray = storageArraySgLongLongIntVal;
34481 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34482 : {
34483 0 : SgLongLongIntVal* tmp = new SgLongLongIntVal ( *storageArray ) ;
34484 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34485 0 : storageArray++ ;
34486 : }
34487 : }
34488 0 : delete [] storageArraySgLongLongIntVal;
34489 2 : SgLongLongIntValStorageClass :: deleteStaticDataOfEasyStorageClasses();
34490 :
34491 :
34492 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLshiftAssignOp );
34493 2 : SgLshiftAssignOpStorageClass* storageArraySgLshiftAssignOp = NULL;
34494 2 : if ( 0 < sizeOfActualPool )
34495 : {
34496 0 : storageArraySgLshiftAssignOp = new SgLshiftAssignOpStorageClass[sizeOfActualPool] ;
34497 0 : inFile.read ( (char*) (storageArraySgLshiftAssignOp) , sizeof ( SgLshiftAssignOpStorageClass ) * sizeOfActualPool) ;
34498 0 : SgLshiftAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34499 : SgLshiftAssignOpStorageClass* storageArray = storageArraySgLshiftAssignOp;
34500 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34501 : {
34502 0 : SgLshiftAssignOp* tmp = new SgLshiftAssignOp ( *storageArray ) ;
34503 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34504 0 : storageArray++ ;
34505 : }
34506 : }
34507 0 : delete [] storageArraySgLshiftAssignOp;
34508 2 : SgLshiftAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34509 :
34510 :
34511 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLshiftOp );
34512 2 : SgLshiftOpStorageClass* storageArraySgLshiftOp = NULL;
34513 2 : if ( 0 < sizeOfActualPool )
34514 : {
34515 28 : storageArraySgLshiftOp = new SgLshiftOpStorageClass[sizeOfActualPool] ;
34516 1 : inFile.read ( (char*) (storageArraySgLshiftOp) , sizeof ( SgLshiftOpStorageClass ) * sizeOfActualPool) ;
34517 1 : SgLshiftOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34518 : SgLshiftOpStorageClass* storageArray = storageArraySgLshiftOp;
34519 28 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34520 : {
34521 27 : SgLshiftOp* tmp = new SgLshiftOp ( *storageArray ) ;
34522 27 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34523 27 : storageArray++ ;
34524 : }
34525 : }
34526 1 : delete [] storageArraySgLshiftOp;
34527 2 : SgLshiftOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34528 :
34529 :
34530 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMagicColonExp );
34531 2 : SgMagicColonExpStorageClass* storageArraySgMagicColonExp = NULL;
34532 2 : if ( 0 < sizeOfActualPool )
34533 : {
34534 0 : storageArraySgMagicColonExp = new SgMagicColonExpStorageClass[sizeOfActualPool] ;
34535 0 : inFile.read ( (char*) (storageArraySgMagicColonExp) , sizeof ( SgMagicColonExpStorageClass ) * sizeOfActualPool) ;
34536 0 : SgMagicColonExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34537 : SgMagicColonExpStorageClass* storageArray = storageArraySgMagicColonExp;
34538 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34539 : {
34540 0 : SgMagicColonExp* tmp = new SgMagicColonExp ( *storageArray ) ;
34541 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34542 0 : storageArray++ ;
34543 : }
34544 : }
34545 0 : delete [] storageArraySgMagicColonExp;
34546 2 : SgMagicColonExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34547 :
34548 :
34549 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMatrixExp );
34550 2 : SgMatrixExpStorageClass* storageArraySgMatrixExp = NULL;
34551 2 : if ( 0 < sizeOfActualPool )
34552 : {
34553 0 : storageArraySgMatrixExp = new SgMatrixExpStorageClass[sizeOfActualPool] ;
34554 0 : inFile.read ( (char*) (storageArraySgMatrixExp) , sizeof ( SgMatrixExpStorageClass ) * sizeOfActualPool) ;
34555 0 : SgMatrixExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34556 : SgMatrixExpStorageClass* storageArray = storageArraySgMatrixExp;
34557 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34558 : {
34559 0 : SgMatrixExp* tmp = new SgMatrixExp ( *storageArray ) ;
34560 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34561 0 : storageArray++ ;
34562 : }
34563 : }
34564 0 : delete [] storageArraySgMatrixExp;
34565 2 : SgMatrixExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34566 :
34567 :
34568 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMatrixTransposeOp );
34569 2 : SgMatrixTransposeOpStorageClass* storageArraySgMatrixTransposeOp = NULL;
34570 2 : if ( 0 < sizeOfActualPool )
34571 : {
34572 0 : storageArraySgMatrixTransposeOp = new SgMatrixTransposeOpStorageClass[sizeOfActualPool] ;
34573 0 : inFile.read ( (char*) (storageArraySgMatrixTransposeOp) , sizeof ( SgMatrixTransposeOpStorageClass ) * sizeOfActualPool) ;
34574 0 : SgMatrixTransposeOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34575 : SgMatrixTransposeOpStorageClass* storageArray = storageArraySgMatrixTransposeOp;
34576 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34577 : {
34578 0 : SgMatrixTransposeOp* tmp = new SgMatrixTransposeOp ( *storageArray ) ;
34579 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34580 0 : storageArray++ ;
34581 : }
34582 : }
34583 0 : delete [] storageArraySgMatrixTransposeOp;
34584 2 : SgMatrixTransposeOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34585 :
34586 :
34587 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMemberFunctionDeclaration );
34588 2 : SgMemberFunctionDeclarationStorageClass* storageArraySgMemberFunctionDeclaration = NULL;
34589 2 : if ( 0 < sizeOfActualPool )
34590 : {
34591 785 : storageArraySgMemberFunctionDeclaration = new SgMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
34592 1 : inFile.read ( (char*) (storageArraySgMemberFunctionDeclaration) , sizeof ( SgMemberFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
34593 1 : SgMemberFunctionDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
34594 : SgMemberFunctionDeclarationStorageClass* storageArray = storageArraySgMemberFunctionDeclaration;
34595 785 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34596 : {
34597 784 : SgMemberFunctionDeclaration* tmp = new SgMemberFunctionDeclaration ( *storageArray ) ;
34598 784 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34599 784 : storageArray++ ;
34600 : }
34601 : }
34602 1 : delete [] storageArraySgMemberFunctionDeclaration;
34603 2 : SgMemberFunctionDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
34604 :
34605 :
34606 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMemberFunctionRefExp );
34607 2 : SgMemberFunctionRefExpStorageClass* storageArraySgMemberFunctionRefExp = NULL;
34608 2 : if ( 0 < sizeOfActualPool )
34609 : {
34610 541 : storageArraySgMemberFunctionRefExp = new SgMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
34611 1 : inFile.read ( (char*) (storageArraySgMemberFunctionRefExp) , sizeof ( SgMemberFunctionRefExpStorageClass ) * sizeOfActualPool) ;
34612 1 : SgMemberFunctionRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34613 : SgMemberFunctionRefExpStorageClass* storageArray = storageArraySgMemberFunctionRefExp;
34614 541 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34615 : {
34616 540 : SgMemberFunctionRefExp* tmp = new SgMemberFunctionRefExp ( *storageArray ) ;
34617 540 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34618 540 : storageArray++ ;
34619 : }
34620 : }
34621 1 : delete [] storageArraySgMemberFunctionRefExp;
34622 2 : SgMemberFunctionRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34623 :
34624 :
34625 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMemberFunctionSymbol );
34626 2 : SgMemberFunctionSymbolStorageClass* storageArraySgMemberFunctionSymbol = NULL;
34627 2 : if ( 0 < sizeOfActualPool )
34628 : {
34629 1954 : storageArraySgMemberFunctionSymbol = new SgMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
34630 1 : inFile.read ( (char*) (storageArraySgMemberFunctionSymbol) , sizeof ( SgMemberFunctionSymbolStorageClass ) * sizeOfActualPool) ;
34631 1 : SgMemberFunctionSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
34632 : SgMemberFunctionSymbolStorageClass* storageArray = storageArraySgMemberFunctionSymbol;
34633 1954 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34634 : {
34635 1953 : SgMemberFunctionSymbol* tmp = new SgMemberFunctionSymbol ( *storageArray ) ;
34636 1953 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34637 1953 : storageArray++ ;
34638 : }
34639 : }
34640 1 : delete [] storageArraySgMemberFunctionSymbol;
34641 2 : SgMemberFunctionSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
34642 :
34643 :
34644 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMemberFunctionType );
34645 2 : SgMemberFunctionTypeStorageClass* storageArraySgMemberFunctionType = NULL;
34646 2 : if ( 0 < sizeOfActualPool )
34647 : {
34648 2168 : storageArraySgMemberFunctionType = new SgMemberFunctionTypeStorageClass[sizeOfActualPool] ;
34649 1 : inFile.read ( (char*) (storageArraySgMemberFunctionType) , sizeof ( SgMemberFunctionTypeStorageClass ) * sizeOfActualPool) ;
34650 1 : SgMemberFunctionTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
34651 : SgMemberFunctionTypeStorageClass* storageArray = storageArraySgMemberFunctionType;
34652 2168 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34653 : {
34654 2167 : SgMemberFunctionType* tmp = new SgMemberFunctionType ( *storageArray ) ;
34655 2167 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34656 2167 : storageArray++ ;
34657 : }
34658 : }
34659 1 : delete [] storageArraySgMemberFunctionType;
34660 2 : SgMemberFunctionTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
34661 :
34662 :
34663 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMembershipOp );
34664 2 : SgMembershipOpStorageClass* storageArraySgMembershipOp = NULL;
34665 2 : if ( 0 < sizeOfActualPool )
34666 : {
34667 0 : storageArraySgMembershipOp = new SgMembershipOpStorageClass[sizeOfActualPool] ;
34668 0 : inFile.read ( (char*) (storageArraySgMembershipOp) , sizeof ( SgMembershipOpStorageClass ) * sizeOfActualPool) ;
34669 0 : SgMembershipOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34670 : SgMembershipOpStorageClass* storageArray = storageArraySgMembershipOp;
34671 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34672 : {
34673 0 : SgMembershipOp* tmp = new SgMembershipOp ( *storageArray ) ;
34674 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34675 0 : storageArray++ ;
34676 : }
34677 : }
34678 0 : delete [] storageArraySgMembershipOp;
34679 2 : SgMembershipOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34680 :
34681 :
34682 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMicrosoftAttributeDeclaration );
34683 2 : SgMicrosoftAttributeDeclarationStorageClass* storageArraySgMicrosoftAttributeDeclaration = NULL;
34684 2 : if ( 0 < sizeOfActualPool )
34685 : {
34686 0 : storageArraySgMicrosoftAttributeDeclaration = new SgMicrosoftAttributeDeclarationStorageClass[sizeOfActualPool] ;
34687 0 : inFile.read ( (char*) (storageArraySgMicrosoftAttributeDeclaration) , sizeof ( SgMicrosoftAttributeDeclarationStorageClass ) * sizeOfActualPool) ;
34688 0 : SgMicrosoftAttributeDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
34689 : SgMicrosoftAttributeDeclarationStorageClass* storageArray = storageArraySgMicrosoftAttributeDeclaration;
34690 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34691 : {
34692 0 : SgMicrosoftAttributeDeclaration* tmp = new SgMicrosoftAttributeDeclaration ( *storageArray ) ;
34693 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34694 0 : storageArray++ ;
34695 : }
34696 : }
34697 0 : delete [] storageArraySgMicrosoftAttributeDeclaration;
34698 2 : SgMicrosoftAttributeDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
34699 :
34700 :
34701 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMinusAssignOp );
34702 2 : SgMinusAssignOpStorageClass* storageArraySgMinusAssignOp = NULL;
34703 2 : if ( 0 < sizeOfActualPool )
34704 : {
34705 11 : storageArraySgMinusAssignOp = new SgMinusAssignOpStorageClass[sizeOfActualPool] ;
34706 1 : inFile.read ( (char*) (storageArraySgMinusAssignOp) , sizeof ( SgMinusAssignOpStorageClass ) * sizeOfActualPool) ;
34707 1 : SgMinusAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34708 : SgMinusAssignOpStorageClass* storageArray = storageArraySgMinusAssignOp;
34709 11 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34710 : {
34711 10 : SgMinusAssignOp* tmp = new SgMinusAssignOp ( *storageArray ) ;
34712 10 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34713 10 : storageArray++ ;
34714 : }
34715 : }
34716 1 : delete [] storageArraySgMinusAssignOp;
34717 2 : SgMinusAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34718 :
34719 :
34720 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMinusMinusOp );
34721 2 : SgMinusMinusOpStorageClass* storageArraySgMinusMinusOp = NULL;
34722 2 : if ( 0 < sizeOfActualPool )
34723 : {
34724 49 : storageArraySgMinusMinusOp = new SgMinusMinusOpStorageClass[sizeOfActualPool] ;
34725 1 : inFile.read ( (char*) (storageArraySgMinusMinusOp) , sizeof ( SgMinusMinusOpStorageClass ) * sizeOfActualPool) ;
34726 1 : SgMinusMinusOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34727 : SgMinusMinusOpStorageClass* storageArray = storageArraySgMinusMinusOp;
34728 49 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34729 : {
34730 48 : SgMinusMinusOp* tmp = new SgMinusMinusOp ( *storageArray ) ;
34731 48 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34732 48 : storageArray++ ;
34733 : }
34734 : }
34735 1 : delete [] storageArraySgMinusMinusOp;
34736 2 : SgMinusMinusOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34737 :
34738 :
34739 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMinusOp );
34740 2 : SgMinusOpStorageClass* storageArraySgMinusOp = NULL;
34741 2 : if ( 0 < sizeOfActualPool )
34742 : {
34743 58 : storageArraySgMinusOp = new SgMinusOpStorageClass[sizeOfActualPool] ;
34744 1 : inFile.read ( (char*) (storageArraySgMinusOp) , sizeof ( SgMinusOpStorageClass ) * sizeOfActualPool) ;
34745 1 : SgMinusOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34746 : SgMinusOpStorageClass* storageArray = storageArraySgMinusOp;
34747 58 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34748 : {
34749 57 : SgMinusOp* tmp = new SgMinusOp ( *storageArray ) ;
34750 57 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34751 57 : storageArray++ ;
34752 : }
34753 : }
34754 1 : delete [] storageArraySgMinusOp;
34755 2 : SgMinusOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34756 :
34757 :
34758 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModAssignOp );
34759 2 : SgModAssignOpStorageClass* storageArraySgModAssignOp = NULL;
34760 2 : if ( 0 < sizeOfActualPool )
34761 : {
34762 0 : storageArraySgModAssignOp = new SgModAssignOpStorageClass[sizeOfActualPool] ;
34763 0 : inFile.read ( (char*) (storageArraySgModAssignOp) , sizeof ( SgModAssignOpStorageClass ) * sizeOfActualPool) ;
34764 0 : SgModAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34765 : SgModAssignOpStorageClass* storageArray = storageArraySgModAssignOp;
34766 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34767 : {
34768 0 : SgModAssignOp* tmp = new SgModAssignOp ( *storageArray ) ;
34769 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34770 0 : storageArray++ ;
34771 : }
34772 : }
34773 0 : delete [] storageArraySgModAssignOp;
34774 2 : SgModAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34775 :
34776 :
34777 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModOp );
34778 2 : SgModOpStorageClass* storageArraySgModOp = NULL;
34779 2 : if ( 0 < sizeOfActualPool )
34780 : {
34781 6 : storageArraySgModOp = new SgModOpStorageClass[sizeOfActualPool] ;
34782 1 : inFile.read ( (char*) (storageArraySgModOp) , sizeof ( SgModOpStorageClass ) * sizeOfActualPool) ;
34783 1 : SgModOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34784 : SgModOpStorageClass* storageArray = storageArraySgModOp;
34785 6 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34786 : {
34787 5 : SgModOp* tmp = new SgModOp ( *storageArray ) ;
34788 5 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34789 5 : storageArray++ ;
34790 : }
34791 : }
34792 1 : delete [] storageArraySgModOp;
34793 2 : SgModOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34794 :
34795 :
34796 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModifier );
34797 2 : SgModifierStorageClass* storageArraySgModifier = NULL;
34798 2 : if ( 0 < sizeOfActualPool )
34799 : {
34800 0 : storageArraySgModifier = new SgModifierStorageClass[sizeOfActualPool] ;
34801 0 : inFile.read ( (char*) (storageArraySgModifier) , sizeof ( SgModifierStorageClass ) * sizeOfActualPool) ;
34802 : SgModifierStorageClass* storageArray = storageArraySgModifier;
34803 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34804 : {
34805 0 : SgModifier* tmp = new SgModifier ( *storageArray ) ;
34806 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34807 0 : storageArray++ ;
34808 : }
34809 : }
34810 0 : delete [] storageArraySgModifier;
34811 :
34812 :
34813 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModifierNodes );
34814 2 : SgModifierNodesStorageClass* storageArraySgModifierNodes = NULL;
34815 2 : if ( 0 < sizeOfActualPool )
34816 : {
34817 0 : storageArraySgModifierNodes = new SgModifierNodesStorageClass[sizeOfActualPool] ;
34818 0 : inFile.read ( (char*) (storageArraySgModifierNodes) , sizeof ( SgModifierNodesStorageClass ) * sizeOfActualPool) ;
34819 0 : SgModifierNodesStorageClass :: readEasyStorageDataFromFile(inFile) ;
34820 : SgModifierNodesStorageClass* storageArray = storageArraySgModifierNodes;
34821 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34822 : {
34823 0 : SgModifierNodes* tmp = new SgModifierNodes ( *storageArray ) ;
34824 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34825 0 : storageArray++ ;
34826 : }
34827 : }
34828 0 : delete [] storageArraySgModifierNodes;
34829 2 : SgModifierNodesStorageClass :: deleteStaticDataOfEasyStorageClasses();
34830 :
34831 :
34832 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModifierType );
34833 2 : SgModifierTypeStorageClass* storageArraySgModifierType = NULL;
34834 2 : if ( 0 < sizeOfActualPool )
34835 : {
34836 878 : storageArraySgModifierType = new SgModifierTypeStorageClass[sizeOfActualPool] ;
34837 2 : inFile.read ( (char*) (storageArraySgModifierType) , sizeof ( SgModifierTypeStorageClass ) * sizeOfActualPool) ;
34838 2 : SgModifierTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
34839 : SgModifierTypeStorageClass* storageArray = storageArraySgModifierType;
34840 878 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34841 : {
34842 876 : SgModifierType* tmp = new SgModifierType ( *storageArray ) ;
34843 876 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34844 876 : storageArray++ ;
34845 : }
34846 : }
34847 2 : delete [] storageArraySgModifierType;
34848 2 : SgModifierTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
34849 :
34850 :
34851 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModuleStatement );
34852 2 : SgModuleStatementStorageClass* storageArraySgModuleStatement = NULL;
34853 2 : if ( 0 < sizeOfActualPool )
34854 : {
34855 0 : storageArraySgModuleStatement = new SgModuleStatementStorageClass[sizeOfActualPool] ;
34856 0 : inFile.read ( (char*) (storageArraySgModuleStatement) , sizeof ( SgModuleStatementStorageClass ) * sizeOfActualPool) ;
34857 0 : SgModuleStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
34858 : SgModuleStatementStorageClass* storageArray = storageArraySgModuleStatement;
34859 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34860 : {
34861 0 : SgModuleStatement* tmp = new SgModuleStatement ( *storageArray ) ;
34862 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34863 0 : storageArray++ ;
34864 : }
34865 : }
34866 0 : delete [] storageArraySgModuleStatement;
34867 2 : SgModuleStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
34868 :
34869 :
34870 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgModuleSymbol );
34871 2 : SgModuleSymbolStorageClass* storageArraySgModuleSymbol = NULL;
34872 2 : if ( 0 < sizeOfActualPool )
34873 : {
34874 0 : storageArraySgModuleSymbol = new SgModuleSymbolStorageClass[sizeOfActualPool] ;
34875 0 : inFile.read ( (char*) (storageArraySgModuleSymbol) , sizeof ( SgModuleSymbolStorageClass ) * sizeOfActualPool) ;
34876 0 : SgModuleSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
34877 : SgModuleSymbolStorageClass* storageArray = storageArraySgModuleSymbol;
34878 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34879 : {
34880 0 : SgModuleSymbol* tmp = new SgModuleSymbol ( *storageArray ) ;
34881 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34882 0 : storageArray++ ;
34883 : }
34884 : }
34885 0 : delete [] storageArraySgModuleSymbol;
34886 2 : SgModuleSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
34887 :
34888 :
34889 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMultAssignOp );
34890 2 : SgMultAssignOpStorageClass* storageArraySgMultAssignOp = NULL;
34891 2 : if ( 0 < sizeOfActualPool )
34892 : {
34893 3 : storageArraySgMultAssignOp = new SgMultAssignOpStorageClass[sizeOfActualPool] ;
34894 1 : inFile.read ( (char*) (storageArraySgMultAssignOp) , sizeof ( SgMultAssignOpStorageClass ) * sizeOfActualPool) ;
34895 1 : SgMultAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34896 : SgMultAssignOpStorageClass* storageArray = storageArraySgMultAssignOp;
34897 3 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34898 : {
34899 2 : SgMultAssignOp* tmp = new SgMultAssignOp ( *storageArray ) ;
34900 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34901 2 : storageArray++ ;
34902 : }
34903 : }
34904 1 : delete [] storageArraySgMultAssignOp;
34905 2 : SgMultAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34906 :
34907 :
34908 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgMultiplyOp );
34909 2 : SgMultiplyOpStorageClass* storageArraySgMultiplyOp = NULL;
34910 2 : if ( 0 < sizeOfActualPool )
34911 : {
34912 67 : storageArraySgMultiplyOp = new SgMultiplyOpStorageClass[sizeOfActualPool] ;
34913 2 : inFile.read ( (char*) (storageArraySgMultiplyOp) , sizeof ( SgMultiplyOpStorageClass ) * sizeOfActualPool) ;
34914 2 : SgMultiplyOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
34915 : SgMultiplyOpStorageClass* storageArray = storageArraySgMultiplyOp;
34916 67 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34917 : {
34918 65 : SgMultiplyOp* tmp = new SgMultiplyOp ( *storageArray ) ;
34919 65 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34920 65 : storageArray++ ;
34921 : }
34922 : }
34923 2 : delete [] storageArraySgMultiplyOp;
34924 2 : SgMultiplyOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
34925 :
34926 :
34927 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgName );
34928 2 : SgNameStorageClass* storageArraySgName = NULL;
34929 2 : if ( 0 < sizeOfActualPool )
34930 : {
34931 0 : storageArraySgName = new SgNameStorageClass[sizeOfActualPool] ;
34932 0 : inFile.read ( (char*) (storageArraySgName) , sizeof ( SgNameStorageClass ) * sizeOfActualPool) ;
34933 0 : SgNameStorageClass :: readEasyStorageDataFromFile(inFile) ;
34934 : SgNameStorageClass* storageArray = storageArraySgName;
34935 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34936 : {
34937 0 : SgName* tmp = new SgName ( *storageArray ) ;
34938 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34939 0 : storageArray++ ;
34940 : }
34941 : }
34942 0 : delete [] storageArraySgName;
34943 2 : SgNameStorageClass :: deleteStaticDataOfEasyStorageClasses();
34944 :
34945 :
34946 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNameGroup );
34947 2 : SgNameGroupStorageClass* storageArraySgNameGroup = NULL;
34948 2 : if ( 0 < sizeOfActualPool )
34949 : {
34950 0 : storageArraySgNameGroup = new SgNameGroupStorageClass[sizeOfActualPool] ;
34951 0 : inFile.read ( (char*) (storageArraySgNameGroup) , sizeof ( SgNameGroupStorageClass ) * sizeOfActualPool) ;
34952 0 : SgNameGroupStorageClass :: readEasyStorageDataFromFile(inFile) ;
34953 : SgNameGroupStorageClass* storageArray = storageArraySgNameGroup;
34954 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34955 : {
34956 0 : SgNameGroup* tmp = new SgNameGroup ( *storageArray ) ;
34957 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34958 0 : storageArray++ ;
34959 : }
34960 : }
34961 0 : delete [] storageArraySgNameGroup;
34962 2 : SgNameGroupStorageClass :: deleteStaticDataOfEasyStorageClasses();
34963 :
34964 :
34965 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamedType );
34966 2 : SgNamedTypeStorageClass* storageArraySgNamedType = NULL;
34967 2 : if ( 0 < sizeOfActualPool )
34968 : {
34969 0 : storageArraySgNamedType = new SgNamedTypeStorageClass[sizeOfActualPool] ;
34970 0 : inFile.read ( (char*) (storageArraySgNamedType) , sizeof ( SgNamedTypeStorageClass ) * sizeOfActualPool) ;
34971 0 : SgNamedTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
34972 : SgNamedTypeStorageClass* storageArray = storageArraySgNamedType;
34973 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34974 : {
34975 0 : SgNamedType* tmp = new SgNamedType ( *storageArray ) ;
34976 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34977 0 : storageArray++ ;
34978 : }
34979 : }
34980 0 : delete [] storageArraySgNamedType;
34981 2 : SgNamedTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
34982 :
34983 :
34984 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamelistStatement );
34985 2 : SgNamelistStatementStorageClass* storageArraySgNamelistStatement = NULL;
34986 2 : if ( 0 < sizeOfActualPool )
34987 : {
34988 0 : storageArraySgNamelistStatement = new SgNamelistStatementStorageClass[sizeOfActualPool] ;
34989 0 : inFile.read ( (char*) (storageArraySgNamelistStatement) , sizeof ( SgNamelistStatementStorageClass ) * sizeOfActualPool) ;
34990 0 : SgNamelistStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
34991 : SgNamelistStatementStorageClass* storageArray = storageArraySgNamelistStatement;
34992 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
34993 : {
34994 0 : SgNamelistStatement* tmp = new SgNamelistStatement ( *storageArray ) ;
34995 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
34996 0 : storageArray++ ;
34997 : }
34998 : }
34999 0 : delete [] storageArraySgNamelistStatement;
35000 2 : SgNamelistStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35001 :
35002 :
35003 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamespaceAliasDeclarationStatement );
35004 2 : SgNamespaceAliasDeclarationStatementStorageClass* storageArraySgNamespaceAliasDeclarationStatement = NULL;
35005 2 : if ( 0 < sizeOfActualPool )
35006 : {
35007 0 : storageArraySgNamespaceAliasDeclarationStatement = new SgNamespaceAliasDeclarationStatementStorageClass[sizeOfActualPool] ;
35008 0 : inFile.read ( (char*) (storageArraySgNamespaceAliasDeclarationStatement) , sizeof ( SgNamespaceAliasDeclarationStatementStorageClass ) * sizeOfActualPool) ;
35009 0 : SgNamespaceAliasDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35010 : SgNamespaceAliasDeclarationStatementStorageClass* storageArray = storageArraySgNamespaceAliasDeclarationStatement;
35011 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35012 : {
35013 0 : SgNamespaceAliasDeclarationStatement* tmp = new SgNamespaceAliasDeclarationStatement ( *storageArray ) ;
35014 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35015 0 : storageArray++ ;
35016 : }
35017 : }
35018 0 : delete [] storageArraySgNamespaceAliasDeclarationStatement;
35019 2 : SgNamespaceAliasDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35020 :
35021 :
35022 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamespaceDeclarationStatement );
35023 2 : SgNamespaceDeclarationStatementStorageClass* storageArraySgNamespaceDeclarationStatement = NULL;
35024 2 : if ( 0 < sizeOfActualPool )
35025 : {
35026 122 : storageArraySgNamespaceDeclarationStatement = new SgNamespaceDeclarationStatementStorageClass[sizeOfActualPool] ;
35027 1 : inFile.read ( (char*) (storageArraySgNamespaceDeclarationStatement) , sizeof ( SgNamespaceDeclarationStatementStorageClass ) * sizeOfActualPool) ;
35028 1 : SgNamespaceDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35029 : SgNamespaceDeclarationStatementStorageClass* storageArray = storageArraySgNamespaceDeclarationStatement;
35030 122 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35031 : {
35032 121 : SgNamespaceDeclarationStatement* tmp = new SgNamespaceDeclarationStatement ( *storageArray ) ;
35033 121 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35034 121 : storageArray++ ;
35035 : }
35036 : }
35037 1 : delete [] storageArraySgNamespaceDeclarationStatement;
35038 2 : SgNamespaceDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35039 :
35040 :
35041 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamespaceDefinitionStatement );
35042 2 : SgNamespaceDefinitionStatementStorageClass* storageArraySgNamespaceDefinitionStatement = NULL;
35043 2 : if ( 0 < sizeOfActualPool )
35044 : {
35045 136 : storageArraySgNamespaceDefinitionStatement = new SgNamespaceDefinitionStatementStorageClass[sizeOfActualPool] ;
35046 1 : inFile.read ( (char*) (storageArraySgNamespaceDefinitionStatement) , sizeof ( SgNamespaceDefinitionStatementStorageClass ) * sizeOfActualPool) ;
35047 1 : SgNamespaceDefinitionStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35048 : SgNamespaceDefinitionStatementStorageClass* storageArray = storageArraySgNamespaceDefinitionStatement;
35049 136 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35050 : {
35051 135 : SgNamespaceDefinitionStatement* tmp = new SgNamespaceDefinitionStatement ( *storageArray ) ;
35052 135 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35053 135 : storageArray++ ;
35054 : }
35055 : }
35056 1 : delete [] storageArraySgNamespaceDefinitionStatement;
35057 2 : SgNamespaceDefinitionStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35058 :
35059 :
35060 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNamespaceSymbol );
35061 2 : SgNamespaceSymbolStorageClass* storageArraySgNamespaceSymbol = NULL;
35062 2 : if ( 0 < sizeOfActualPool )
35063 : {
35064 15 : storageArraySgNamespaceSymbol = new SgNamespaceSymbolStorageClass[sizeOfActualPool] ;
35065 1 : inFile.read ( (char*) (storageArraySgNamespaceSymbol) , sizeof ( SgNamespaceSymbolStorageClass ) * sizeOfActualPool) ;
35066 1 : SgNamespaceSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
35067 : SgNamespaceSymbolStorageClass* storageArray = storageArraySgNamespaceSymbol;
35068 15 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35069 : {
35070 14 : SgNamespaceSymbol* tmp = new SgNamespaceSymbol ( *storageArray ) ;
35071 14 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35072 14 : storageArray++ ;
35073 : }
35074 : }
35075 1 : delete [] storageArraySgNamespaceSymbol;
35076 2 : SgNamespaceSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
35077 :
35078 :
35079 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNaryOp );
35080 2 : SgNaryOpStorageClass* storageArraySgNaryOp = NULL;
35081 2 : if ( 0 < sizeOfActualPool )
35082 : {
35083 0 : storageArraySgNaryOp = new SgNaryOpStorageClass[sizeOfActualPool] ;
35084 0 : inFile.read ( (char*) (storageArraySgNaryOp) , sizeof ( SgNaryOpStorageClass ) * sizeOfActualPool) ;
35085 0 : SgNaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35086 : SgNaryOpStorageClass* storageArray = storageArraySgNaryOp;
35087 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35088 : {
35089 0 : SgNaryOp* tmp = new SgNaryOp ( *storageArray ) ;
35090 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35091 0 : storageArray++ ;
35092 : }
35093 : }
35094 0 : delete [] storageArraySgNaryOp;
35095 2 : SgNaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35096 :
35097 :
35098 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNaryBooleanOp );
35099 2 : SgNaryBooleanOpStorageClass* storageArraySgNaryBooleanOp = NULL;
35100 2 : if ( 0 < sizeOfActualPool )
35101 : {
35102 0 : storageArraySgNaryBooleanOp = new SgNaryBooleanOpStorageClass[sizeOfActualPool] ;
35103 0 : inFile.read ( (char*) (storageArraySgNaryBooleanOp) , sizeof ( SgNaryBooleanOpStorageClass ) * sizeOfActualPool) ;
35104 0 : SgNaryBooleanOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35105 : SgNaryBooleanOpStorageClass* storageArray = storageArraySgNaryBooleanOp;
35106 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35107 : {
35108 0 : SgNaryBooleanOp* tmp = new SgNaryBooleanOp ( *storageArray ) ;
35109 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35110 0 : storageArray++ ;
35111 : }
35112 : }
35113 0 : delete [] storageArraySgNaryBooleanOp;
35114 2 : SgNaryBooleanOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35115 :
35116 :
35117 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNaryComparisonOp );
35118 2 : SgNaryComparisonOpStorageClass* storageArraySgNaryComparisonOp = NULL;
35119 2 : if ( 0 < sizeOfActualPool )
35120 : {
35121 0 : storageArraySgNaryComparisonOp = new SgNaryComparisonOpStorageClass[sizeOfActualPool] ;
35122 0 : inFile.read ( (char*) (storageArraySgNaryComparisonOp) , sizeof ( SgNaryComparisonOpStorageClass ) * sizeOfActualPool) ;
35123 0 : SgNaryComparisonOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35124 : SgNaryComparisonOpStorageClass* storageArray = storageArraySgNaryComparisonOp;
35125 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35126 : {
35127 0 : SgNaryComparisonOp* tmp = new SgNaryComparisonOp ( *storageArray ) ;
35128 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35129 0 : storageArray++ ;
35130 : }
35131 : }
35132 0 : delete [] storageArraySgNaryComparisonOp;
35133 2 : SgNaryComparisonOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35134 :
35135 :
35136 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNewExp );
35137 2 : SgNewExpStorageClass* storageArraySgNewExp = NULL;
35138 2 : if ( 0 < sizeOfActualPool )
35139 : {
35140 15 : storageArraySgNewExp = new SgNewExpStorageClass[sizeOfActualPool] ;
35141 1 : inFile.read ( (char*) (storageArraySgNewExp) , sizeof ( SgNewExpStorageClass ) * sizeOfActualPool) ;
35142 1 : SgNewExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35143 : SgNewExpStorageClass* storageArray = storageArraySgNewExp;
35144 15 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35145 : {
35146 14 : SgNewExp* tmp = new SgNewExp ( *storageArray ) ;
35147 14 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35148 14 : storageArray++ ;
35149 : }
35150 : }
35151 1 : delete [] storageArraySgNewExp;
35152 2 : SgNewExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35153 :
35154 :
35155 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNode );
35156 2 : SgNodeStorageClass* storageArraySgNode = NULL;
35157 2 : if ( 0 < sizeOfActualPool )
35158 : {
35159 0 : storageArraySgNode = new SgNodeStorageClass[sizeOfActualPool] ;
35160 0 : inFile.read ( (char*) (storageArraySgNode) , sizeof ( SgNodeStorageClass ) * sizeOfActualPool) ;
35161 : SgNodeStorageClass* storageArray = storageArraySgNode;
35162 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35163 : {
35164 0 : SgNode* tmp = new SgNode ( *storageArray ) ;
35165 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35166 0 : storageArray++ ;
35167 : }
35168 : }
35169 0 : delete [] storageArraySgNode;
35170 :
35171 :
35172 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNoexceptOp );
35173 2 : SgNoexceptOpStorageClass* storageArraySgNoexceptOp = NULL;
35174 2 : if ( 0 < sizeOfActualPool )
35175 : {
35176 19 : storageArraySgNoexceptOp = new SgNoexceptOpStorageClass[sizeOfActualPool] ;
35177 1 : inFile.read ( (char*) (storageArraySgNoexceptOp) , sizeof ( SgNoexceptOpStorageClass ) * sizeOfActualPool) ;
35178 1 : SgNoexceptOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35179 : SgNoexceptOpStorageClass* storageArray = storageArraySgNoexceptOp;
35180 19 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35181 : {
35182 18 : SgNoexceptOp* tmp = new SgNoexceptOp ( *storageArray ) ;
35183 18 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35184 18 : storageArray++ ;
35185 : }
35186 : }
35187 1 : delete [] storageArraySgNoexceptOp;
35188 2 : SgNoexceptOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35189 :
35190 :
35191 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNotEqualOp );
35192 2 : SgNotEqualOpStorageClass* storageArraySgNotEqualOp = NULL;
35193 2 : if ( 0 < sizeOfActualPool )
35194 : {
35195 96 : storageArraySgNotEqualOp = new SgNotEqualOpStorageClass[sizeOfActualPool] ;
35196 1 : inFile.read ( (char*) (storageArraySgNotEqualOp) , sizeof ( SgNotEqualOpStorageClass ) * sizeOfActualPool) ;
35197 1 : SgNotEqualOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35198 : SgNotEqualOpStorageClass* storageArray = storageArraySgNotEqualOp;
35199 96 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35200 : {
35201 95 : SgNotEqualOp* tmp = new SgNotEqualOp ( *storageArray ) ;
35202 95 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35203 95 : storageArray++ ;
35204 : }
35205 : }
35206 1 : delete [] storageArraySgNotEqualOp;
35207 2 : SgNotEqualOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35208 :
35209 :
35210 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNotOp );
35211 2 : SgNotOpStorageClass* storageArraySgNotOp = NULL;
35212 2 : if ( 0 < sizeOfActualPool )
35213 : {
35214 221 : storageArraySgNotOp = new SgNotOpStorageClass[sizeOfActualPool] ;
35215 1 : inFile.read ( (char*) (storageArraySgNotOp) , sizeof ( SgNotOpStorageClass ) * sizeOfActualPool) ;
35216 1 : SgNotOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35217 : SgNotOpStorageClass* storageArray = storageArraySgNotOp;
35218 221 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35219 : {
35220 220 : SgNotOp* tmp = new SgNotOp ( *storageArray ) ;
35221 220 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35222 220 : storageArray++ ;
35223 : }
35224 : }
35225 1 : delete [] storageArraySgNotOp;
35226 2 : SgNotOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35227 :
35228 :
35229 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonMembershipOp );
35230 2 : SgNonMembershipOpStorageClass* storageArraySgNonMembershipOp = NULL;
35231 2 : if ( 0 < sizeOfActualPool )
35232 : {
35233 0 : storageArraySgNonMembershipOp = new SgNonMembershipOpStorageClass[sizeOfActualPool] ;
35234 0 : inFile.read ( (char*) (storageArraySgNonMembershipOp) , sizeof ( SgNonMembershipOpStorageClass ) * sizeOfActualPool) ;
35235 0 : SgNonMembershipOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35236 : SgNonMembershipOpStorageClass* storageArray = storageArraySgNonMembershipOp;
35237 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35238 : {
35239 0 : SgNonMembershipOp* tmp = new SgNonMembershipOp ( *storageArray ) ;
35240 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35241 0 : storageArray++ ;
35242 : }
35243 : }
35244 0 : delete [] storageArraySgNonMembershipOp;
35245 2 : SgNonMembershipOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35246 :
35247 :
35248 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonrealDecl );
35249 2 : SgNonrealDeclStorageClass* storageArraySgNonrealDecl = NULL;
35250 2 : if ( 0 < sizeOfActualPool )
35251 : {
35252 5081 : storageArraySgNonrealDecl = new SgNonrealDeclStorageClass[sizeOfActualPool] ;
35253 1 : inFile.read ( (char*) (storageArraySgNonrealDecl) , sizeof ( SgNonrealDeclStorageClass ) * sizeOfActualPool) ;
35254 1 : SgNonrealDeclStorageClass :: readEasyStorageDataFromFile(inFile) ;
35255 : SgNonrealDeclStorageClass* storageArray = storageArraySgNonrealDecl;
35256 5081 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35257 : {
35258 5080 : SgNonrealDecl* tmp = new SgNonrealDecl ( *storageArray ) ;
35259 5080 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35260 5080 : storageArray++ ;
35261 : }
35262 : }
35263 1 : delete [] storageArraySgNonrealDecl;
35264 2 : SgNonrealDeclStorageClass :: deleteStaticDataOfEasyStorageClasses();
35265 :
35266 :
35267 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonrealRefExp );
35268 2 : SgNonrealRefExpStorageClass* storageArraySgNonrealRefExp = NULL;
35269 2 : if ( 0 < sizeOfActualPool )
35270 : {
35271 1495 : storageArraySgNonrealRefExp = new SgNonrealRefExpStorageClass[sizeOfActualPool] ;
35272 1 : inFile.read ( (char*) (storageArraySgNonrealRefExp) , sizeof ( SgNonrealRefExpStorageClass ) * sizeOfActualPool) ;
35273 1 : SgNonrealRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35274 : SgNonrealRefExpStorageClass* storageArray = storageArraySgNonrealRefExp;
35275 1495 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35276 : {
35277 1494 : SgNonrealRefExp* tmp = new SgNonrealRefExp ( *storageArray ) ;
35278 1494 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35279 1494 : storageArray++ ;
35280 : }
35281 : }
35282 1 : delete [] storageArraySgNonrealRefExp;
35283 2 : SgNonrealRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35284 :
35285 :
35286 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonrealSymbol );
35287 2 : SgNonrealSymbolStorageClass* storageArraySgNonrealSymbol = NULL;
35288 2 : if ( 0 < sizeOfActualPool )
35289 : {
35290 5081 : storageArraySgNonrealSymbol = new SgNonrealSymbolStorageClass[sizeOfActualPool] ;
35291 1 : inFile.read ( (char*) (storageArraySgNonrealSymbol) , sizeof ( SgNonrealSymbolStorageClass ) * sizeOfActualPool) ;
35292 1 : SgNonrealSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
35293 : SgNonrealSymbolStorageClass* storageArray = storageArraySgNonrealSymbol;
35294 5081 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35295 : {
35296 5080 : SgNonrealSymbol* tmp = new SgNonrealSymbol ( *storageArray ) ;
35297 5080 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35298 5080 : storageArray++ ;
35299 : }
35300 : }
35301 1 : delete [] storageArraySgNonrealSymbol;
35302 2 : SgNonrealSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
35303 :
35304 :
35305 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonrealType );
35306 2 : SgNonrealTypeStorageClass* storageArraySgNonrealType = NULL;
35307 2 : if ( 0 < sizeOfActualPool )
35308 : {
35309 5081 : storageArraySgNonrealType = new SgNonrealTypeStorageClass[sizeOfActualPool] ;
35310 1 : inFile.read ( (char*) (storageArraySgNonrealType) , sizeof ( SgNonrealTypeStorageClass ) * sizeOfActualPool) ;
35311 1 : SgNonrealTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
35312 : SgNonrealTypeStorageClass* storageArray = storageArraySgNonrealType;
35313 5081 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35314 : {
35315 5080 : SgNonrealType* tmp = new SgNonrealType ( *storageArray ) ;
35316 5080 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35317 5080 : storageArray++ ;
35318 : }
35319 : }
35320 1 : delete [] storageArraySgNonrealType;
35321 2 : SgNonrealTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
35322 :
35323 :
35324 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNonrealBaseClass );
35325 2 : SgNonrealBaseClassStorageClass* storageArraySgNonrealBaseClass = NULL;
35326 2 : if ( 0 < sizeOfActualPool )
35327 : {
35328 1 : storageArraySgNonrealBaseClass = new SgNonrealBaseClassStorageClass[sizeOfActualPool] ;
35329 1 : inFile.read ( (char*) (storageArraySgNonrealBaseClass) , sizeof ( SgNonrealBaseClassStorageClass ) * sizeOfActualPool) ;
35330 : SgNonrealBaseClassStorageClass* storageArray = storageArraySgNonrealBaseClass;
35331 201 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35332 : {
35333 200 : SgNonrealBaseClass* tmp = new SgNonrealBaseClass ( *storageArray ) ;
35334 200 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35335 200 : storageArray++ ;
35336 : }
35337 : }
35338 1 : delete [] storageArraySgNonrealBaseClass;
35339 :
35340 :
35341 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNullExpression );
35342 2 : SgNullExpressionStorageClass* storageArraySgNullExpression = NULL;
35343 2 : if ( 0 < sizeOfActualPool )
35344 : {
35345 123 : storageArraySgNullExpression = new SgNullExpressionStorageClass[sizeOfActualPool] ;
35346 2 : inFile.read ( (char*) (storageArraySgNullExpression) , sizeof ( SgNullExpressionStorageClass ) * sizeOfActualPool) ;
35347 2 : SgNullExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
35348 : SgNullExpressionStorageClass* storageArray = storageArraySgNullExpression;
35349 123 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35350 : {
35351 121 : SgNullExpression* tmp = new SgNullExpression ( *storageArray ) ;
35352 121 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35353 121 : storageArray++ ;
35354 : }
35355 : }
35356 2 : delete [] storageArraySgNullExpression;
35357 2 : SgNullExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
35358 :
35359 :
35360 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNullptrValExp );
35361 2 : SgNullptrValExpStorageClass* storageArraySgNullptrValExp = NULL;
35362 2 : if ( 0 < sizeOfActualPool )
35363 : {
35364 7 : storageArraySgNullptrValExp = new SgNullptrValExpStorageClass[sizeOfActualPool] ;
35365 1 : inFile.read ( (char*) (storageArraySgNullptrValExp) , sizeof ( SgNullptrValExpStorageClass ) * sizeOfActualPool) ;
35366 1 : SgNullptrValExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
35367 : SgNullptrValExpStorageClass* storageArray = storageArraySgNullptrValExp;
35368 7 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35369 : {
35370 6 : SgNullptrValExp* tmp = new SgNullptrValExp ( *storageArray ) ;
35371 6 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35372 6 : storageArray++ ;
35373 : }
35374 : }
35375 1 : delete [] storageArraySgNullptrValExp;
35376 2 : SgNullptrValExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
35377 :
35378 :
35379 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNullStatement );
35380 2 : SgNullStatementStorageClass* storageArraySgNullStatement = NULL;
35381 2 : if ( 0 < sizeOfActualPool )
35382 : {
35383 21 : storageArraySgNullStatement = new SgNullStatementStorageClass[sizeOfActualPool] ;
35384 1 : inFile.read ( (char*) (storageArraySgNullStatement) , sizeof ( SgNullStatementStorageClass ) * sizeOfActualPool) ;
35385 1 : SgNullStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35386 : SgNullStatementStorageClass* storageArray = storageArraySgNullStatement;
35387 21 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35388 : {
35389 20 : SgNullStatement* tmp = new SgNullStatement ( *storageArray ) ;
35390 20 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35391 20 : storageArray++ ;
35392 : }
35393 : }
35394 1 : delete [] storageArraySgNullStatement;
35395 2 : SgNullStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35396 :
35397 :
35398 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgNullifyStatement );
35399 2 : SgNullifyStatementStorageClass* storageArraySgNullifyStatement = NULL;
35400 2 : if ( 0 < sizeOfActualPool )
35401 : {
35402 0 : storageArraySgNullifyStatement = new SgNullifyStatementStorageClass[sizeOfActualPool] ;
35403 0 : inFile.read ( (char*) (storageArraySgNullifyStatement) , sizeof ( SgNullifyStatementStorageClass ) * sizeOfActualPool) ;
35404 0 : SgNullifyStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35405 : SgNullifyStatementStorageClass* storageArray = storageArraySgNullifyStatement;
35406 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35407 : {
35408 0 : SgNullifyStatement* tmp = new SgNullifyStatement ( *storageArray ) ;
35409 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35410 0 : storageArray++ ;
35411 : }
35412 : }
35413 0 : delete [] storageArraySgNullifyStatement;
35414 2 : SgNullifyStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35415 :
35416 :
35417 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAtomicStatement );
35418 2 : SgOmpAtomicStatementStorageClass* storageArraySgOmpAtomicStatement = NULL;
35419 2 : if ( 0 < sizeOfActualPool )
35420 : {
35421 0 : storageArraySgOmpAtomicStatement = new SgOmpAtomicStatementStorageClass[sizeOfActualPool] ;
35422 0 : inFile.read ( (char*) (storageArraySgOmpAtomicStatement) , sizeof ( SgOmpAtomicStatementStorageClass ) * sizeOfActualPool) ;
35423 0 : SgOmpAtomicStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35424 : SgOmpAtomicStatementStorageClass* storageArray = storageArraySgOmpAtomicStatement;
35425 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35426 : {
35427 0 : SgOmpAtomicStatement* tmp = new SgOmpAtomicStatement ( *storageArray ) ;
35428 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35429 0 : storageArray++ ;
35430 : }
35431 : }
35432 0 : delete [] storageArraySgOmpAtomicStatement;
35433 2 : SgOmpAtomicStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35434 :
35435 :
35436 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpBarrierStatement );
35437 2 : SgOmpBarrierStatementStorageClass* storageArraySgOmpBarrierStatement = NULL;
35438 2 : if ( 0 < sizeOfActualPool )
35439 : {
35440 0 : storageArraySgOmpBarrierStatement = new SgOmpBarrierStatementStorageClass[sizeOfActualPool] ;
35441 0 : inFile.read ( (char*) (storageArraySgOmpBarrierStatement) , sizeof ( SgOmpBarrierStatementStorageClass ) * sizeOfActualPool) ;
35442 0 : SgOmpBarrierStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35443 : SgOmpBarrierStatementStorageClass* storageArray = storageArraySgOmpBarrierStatement;
35444 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35445 : {
35446 0 : SgOmpBarrierStatement* tmp = new SgOmpBarrierStatement ( *storageArray ) ;
35447 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35448 0 : storageArray++ ;
35449 : }
35450 : }
35451 0 : delete [] storageArraySgOmpBarrierStatement;
35452 2 : SgOmpBarrierStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35453 :
35454 :
35455 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCriticalStatement );
35456 2 : SgOmpCriticalStatementStorageClass* storageArraySgOmpCriticalStatement = NULL;
35457 2 : if ( 0 < sizeOfActualPool )
35458 : {
35459 0 : storageArraySgOmpCriticalStatement = new SgOmpCriticalStatementStorageClass[sizeOfActualPool] ;
35460 0 : inFile.read ( (char*) (storageArraySgOmpCriticalStatement) , sizeof ( SgOmpCriticalStatementStorageClass ) * sizeOfActualPool) ;
35461 0 : SgOmpCriticalStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35462 : SgOmpCriticalStatementStorageClass* storageArray = storageArraySgOmpCriticalStatement;
35463 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35464 : {
35465 0 : SgOmpCriticalStatement* tmp = new SgOmpCriticalStatement ( *storageArray ) ;
35466 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35467 0 : storageArray++ ;
35468 : }
35469 : }
35470 0 : delete [] storageArraySgOmpCriticalStatement;
35471 2 : SgOmpCriticalStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35472 :
35473 :
35474 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirFieldBodyStatement );
35475 2 : SgUpirFieldBodyStatementStorageClass* storageArraySgUpirFieldBodyStatement = NULL;
35476 2 : if ( 0 < sizeOfActualPool )
35477 : {
35478 0 : storageArraySgUpirFieldBodyStatement = new SgUpirFieldBodyStatementStorageClass[sizeOfActualPool] ;
35479 0 : inFile.read ( (char*) (storageArraySgUpirFieldBodyStatement) , sizeof ( SgUpirFieldBodyStatementStorageClass ) * sizeOfActualPool) ;
35480 0 : SgUpirFieldBodyStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35481 : SgUpirFieldBodyStatementStorageClass* storageArray = storageArraySgUpirFieldBodyStatement;
35482 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35483 : {
35484 0 : SgUpirFieldBodyStatement* tmp = new SgUpirFieldBodyStatement ( *storageArray ) ;
35485 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35486 0 : storageArray++ ;
35487 : }
35488 : }
35489 0 : delete [] storageArraySgUpirFieldBodyStatement;
35490 2 : SgUpirFieldBodyStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35491 :
35492 :
35493 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirBodyStatement );
35494 2 : SgUpirBodyStatementStorageClass* storageArraySgUpirBodyStatement = NULL;
35495 2 : if ( 0 < sizeOfActualPool )
35496 : {
35497 0 : storageArraySgUpirBodyStatement = new SgUpirBodyStatementStorageClass[sizeOfActualPool] ;
35498 0 : inFile.read ( (char*) (storageArraySgUpirBodyStatement) , sizeof ( SgUpirBodyStatementStorageClass ) * sizeOfActualPool) ;
35499 0 : SgUpirBodyStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35500 : SgUpirBodyStatementStorageClass* storageArray = storageArraySgUpirBodyStatement;
35501 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35502 : {
35503 0 : SgUpirBodyStatement* tmp = new SgUpirBodyStatement ( *storageArray ) ;
35504 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35505 0 : storageArray++ ;
35506 : }
35507 : }
35508 0 : delete [] storageArraySgUpirBodyStatement;
35509 2 : SgUpirBodyStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35510 :
35511 :
35512 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirFieldStatement );
35513 2 : SgUpirFieldStatementStorageClass* storageArraySgUpirFieldStatement = NULL;
35514 2 : if ( 0 < sizeOfActualPool )
35515 : {
35516 0 : storageArraySgUpirFieldStatement = new SgUpirFieldStatementStorageClass[sizeOfActualPool] ;
35517 0 : inFile.read ( (char*) (storageArraySgUpirFieldStatement) , sizeof ( SgUpirFieldStatementStorageClass ) * sizeOfActualPool) ;
35518 0 : SgUpirFieldStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35519 : SgUpirFieldStatementStorageClass* storageArray = storageArraySgUpirFieldStatement;
35520 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35521 : {
35522 0 : SgUpirFieldStatement* tmp = new SgUpirFieldStatement ( *storageArray ) ;
35523 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35524 0 : storageArray++ ;
35525 : }
35526 : }
35527 0 : delete [] storageArraySgUpirFieldStatement;
35528 2 : SgUpirFieldStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35529 :
35530 :
35531 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDoStatement );
35532 2 : SgOmpDoStatementStorageClass* storageArraySgOmpDoStatement = NULL;
35533 2 : if ( 0 < sizeOfActualPool )
35534 : {
35535 0 : storageArraySgOmpDoStatement = new SgOmpDoStatementStorageClass[sizeOfActualPool] ;
35536 0 : inFile.read ( (char*) (storageArraySgOmpDoStatement) , sizeof ( SgOmpDoStatementStorageClass ) * sizeOfActualPool) ;
35537 0 : SgOmpDoStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35538 : SgOmpDoStatementStorageClass* storageArray = storageArraySgOmpDoStatement;
35539 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35540 : {
35541 0 : SgOmpDoStatement* tmp = new SgOmpDoStatement ( *storageArray ) ;
35542 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35543 0 : storageArray++ ;
35544 : }
35545 : }
35546 0 : delete [] storageArraySgOmpDoStatement;
35547 2 : SgOmpDoStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35548 :
35549 :
35550 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpFlushStatement );
35551 2 : SgOmpFlushStatementStorageClass* storageArraySgOmpFlushStatement = NULL;
35552 2 : if ( 0 < sizeOfActualPool )
35553 : {
35554 0 : storageArraySgOmpFlushStatement = new SgOmpFlushStatementStorageClass[sizeOfActualPool] ;
35555 0 : inFile.read ( (char*) (storageArraySgOmpFlushStatement) , sizeof ( SgOmpFlushStatementStorageClass ) * sizeOfActualPool) ;
35556 0 : SgOmpFlushStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35557 : SgOmpFlushStatementStorageClass* storageArray = storageArraySgOmpFlushStatement;
35558 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35559 : {
35560 0 : SgOmpFlushStatement* tmp = new SgOmpFlushStatement ( *storageArray ) ;
35561 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35562 0 : storageArray++ ;
35563 : }
35564 : }
35565 0 : delete [] storageArraySgOmpFlushStatement;
35566 2 : SgOmpFlushStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35567 :
35568 :
35569 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAllocateStatement );
35570 2 : SgOmpAllocateStatementStorageClass* storageArraySgOmpAllocateStatement = NULL;
35571 2 : if ( 0 < sizeOfActualPool )
35572 : {
35573 0 : storageArraySgOmpAllocateStatement = new SgOmpAllocateStatementStorageClass[sizeOfActualPool] ;
35574 0 : inFile.read ( (char*) (storageArraySgOmpAllocateStatement) , sizeof ( SgOmpAllocateStatementStorageClass ) * sizeOfActualPool) ;
35575 0 : SgOmpAllocateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35576 : SgOmpAllocateStatementStorageClass* storageArray = storageArraySgOmpAllocateStatement;
35577 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35578 : {
35579 0 : SgOmpAllocateStatement* tmp = new SgOmpAllocateStatement ( *storageArray ) ;
35580 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35581 0 : storageArray++ ;
35582 : }
35583 : }
35584 0 : delete [] storageArraySgOmpAllocateStatement;
35585 2 : SgOmpAllocateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35586 :
35587 :
35588 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDeclareSimdStatement );
35589 2 : SgOmpDeclareSimdStatementStorageClass* storageArraySgOmpDeclareSimdStatement = NULL;
35590 2 : if ( 0 < sizeOfActualPool )
35591 : {
35592 0 : storageArraySgOmpDeclareSimdStatement = new SgOmpDeclareSimdStatementStorageClass[sizeOfActualPool] ;
35593 0 : inFile.read ( (char*) (storageArraySgOmpDeclareSimdStatement) , sizeof ( SgOmpDeclareSimdStatementStorageClass ) * sizeOfActualPool) ;
35594 0 : SgOmpDeclareSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35595 : SgOmpDeclareSimdStatementStorageClass* storageArray = storageArraySgOmpDeclareSimdStatement;
35596 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35597 : {
35598 0 : SgOmpDeclareSimdStatement* tmp = new SgOmpDeclareSimdStatement ( *storageArray ) ;
35599 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35600 0 : storageArray++ ;
35601 : }
35602 : }
35603 0 : delete [] storageArraySgOmpDeclareSimdStatement;
35604 2 : SgOmpDeclareSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35605 :
35606 :
35607 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirWorksharingStatement );
35608 2 : SgUpirWorksharingStatementStorageClass* storageArraySgUpirWorksharingStatement = NULL;
35609 2 : if ( 0 < sizeOfActualPool )
35610 : {
35611 0 : storageArraySgUpirWorksharingStatement = new SgUpirWorksharingStatementStorageClass[sizeOfActualPool] ;
35612 0 : inFile.read ( (char*) (storageArraySgUpirWorksharingStatement) , sizeof ( SgUpirWorksharingStatementStorageClass ) * sizeOfActualPool) ;
35613 0 : SgUpirWorksharingStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35614 : SgUpirWorksharingStatementStorageClass* storageArray = storageArraySgUpirWorksharingStatement;
35615 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35616 : {
35617 0 : SgUpirWorksharingStatement* tmp = new SgUpirWorksharingStatement ( *storageArray ) ;
35618 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35619 0 : storageArray++ ;
35620 : }
35621 : }
35622 0 : delete [] storageArraySgUpirWorksharingStatement;
35623 2 : SgUpirWorksharingStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35624 :
35625 :
35626 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpForSimdStatement );
35627 2 : SgOmpForSimdStatementStorageClass* storageArraySgOmpForSimdStatement = NULL;
35628 2 : if ( 0 < sizeOfActualPool )
35629 : {
35630 0 : storageArraySgOmpForSimdStatement = new SgOmpForSimdStatementStorageClass[sizeOfActualPool] ;
35631 0 : inFile.read ( (char*) (storageArraySgOmpForSimdStatement) , sizeof ( SgOmpForSimdStatementStorageClass ) * sizeOfActualPool) ;
35632 0 : SgOmpForSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35633 : SgOmpForSimdStatementStorageClass* storageArray = storageArraySgOmpForSimdStatement;
35634 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35635 : {
35636 0 : SgOmpForSimdStatement* tmp = new SgOmpForSimdStatement ( *storageArray ) ;
35637 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35638 0 : storageArray++ ;
35639 : }
35640 : }
35641 0 : delete [] storageArraySgOmpForSimdStatement;
35642 2 : SgOmpForSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35643 :
35644 :
35645 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMasterStatement );
35646 2 : SgOmpMasterStatementStorageClass* storageArraySgOmpMasterStatement = NULL;
35647 2 : if ( 0 < sizeOfActualPool )
35648 : {
35649 0 : storageArraySgOmpMasterStatement = new SgOmpMasterStatementStorageClass[sizeOfActualPool] ;
35650 0 : inFile.read ( (char*) (storageArraySgOmpMasterStatement) , sizeof ( SgOmpMasterStatementStorageClass ) * sizeOfActualPool) ;
35651 0 : SgOmpMasterStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35652 : SgOmpMasterStatementStorageClass* storageArray = storageArraySgOmpMasterStatement;
35653 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35654 : {
35655 0 : SgOmpMasterStatement* tmp = new SgOmpMasterStatement ( *storageArray ) ;
35656 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35657 0 : storageArray++ ;
35658 : }
35659 : }
35660 0 : delete [] storageArraySgOmpMasterStatement;
35661 2 : SgOmpMasterStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35662 :
35663 :
35664 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskyieldStatement );
35665 2 : SgOmpTaskyieldStatementStorageClass* storageArraySgOmpTaskyieldStatement = NULL;
35666 2 : if ( 0 < sizeOfActualPool )
35667 : {
35668 0 : storageArraySgOmpTaskyieldStatement = new SgOmpTaskyieldStatementStorageClass[sizeOfActualPool] ;
35669 0 : inFile.read ( (char*) (storageArraySgOmpTaskyieldStatement) , sizeof ( SgOmpTaskyieldStatementStorageClass ) * sizeOfActualPool) ;
35670 0 : SgOmpTaskyieldStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35671 : SgOmpTaskyieldStatementStorageClass* storageArray = storageArraySgOmpTaskyieldStatement;
35672 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35673 : {
35674 0 : SgOmpTaskyieldStatement* tmp = new SgOmpTaskyieldStatement ( *storageArray ) ;
35675 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35676 0 : storageArray++ ;
35677 : }
35678 : }
35679 0 : delete [] storageArraySgOmpTaskyieldStatement;
35680 2 : SgOmpTaskyieldStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35681 :
35682 :
35683 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMetadirectiveStatement );
35684 2 : SgOmpMetadirectiveStatementStorageClass* storageArraySgOmpMetadirectiveStatement = NULL;
35685 2 : if ( 0 < sizeOfActualPool )
35686 : {
35687 0 : storageArraySgOmpMetadirectiveStatement = new SgOmpMetadirectiveStatementStorageClass[sizeOfActualPool] ;
35688 0 : inFile.read ( (char*) (storageArraySgOmpMetadirectiveStatement) , sizeof ( SgOmpMetadirectiveStatementStorageClass ) * sizeOfActualPool) ;
35689 0 : SgOmpMetadirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35690 : SgOmpMetadirectiveStatementStorageClass* storageArray = storageArraySgOmpMetadirectiveStatement;
35691 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35692 : {
35693 0 : SgOmpMetadirectiveStatement* tmp = new SgOmpMetadirectiveStatement ( *storageArray ) ;
35694 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35695 0 : storageArray++ ;
35696 : }
35697 : }
35698 0 : delete [] storageArraySgOmpMetadirectiveStatement;
35699 2 : SgOmpMetadirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35700 :
35701 :
35702 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpOrderedStatement );
35703 2 : SgOmpOrderedStatementStorageClass* storageArraySgOmpOrderedStatement = NULL;
35704 2 : if ( 0 < sizeOfActualPool )
35705 : {
35706 0 : storageArraySgOmpOrderedStatement = new SgOmpOrderedStatementStorageClass[sizeOfActualPool] ;
35707 0 : inFile.read ( (char*) (storageArraySgOmpOrderedStatement) , sizeof ( SgOmpOrderedStatementStorageClass ) * sizeOfActualPool) ;
35708 0 : SgOmpOrderedStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35709 : SgOmpOrderedStatementStorageClass* storageArray = storageArraySgOmpOrderedStatement;
35710 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35711 : {
35712 0 : SgOmpOrderedStatement* tmp = new SgOmpOrderedStatement ( *storageArray ) ;
35713 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35714 0 : storageArray++ ;
35715 : }
35716 : }
35717 0 : delete [] storageArraySgOmpOrderedStatement;
35718 2 : SgOmpOrderedStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35719 :
35720 :
35721 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpOrderedDependStatement );
35722 2 : SgOmpOrderedDependStatementStorageClass* storageArraySgOmpOrderedDependStatement = NULL;
35723 2 : if ( 0 < sizeOfActualPool )
35724 : {
35725 0 : storageArraySgOmpOrderedDependStatement = new SgOmpOrderedDependStatementStorageClass[sizeOfActualPool] ;
35726 0 : inFile.read ( (char*) (storageArraySgOmpOrderedDependStatement) , sizeof ( SgOmpOrderedDependStatementStorageClass ) * sizeOfActualPool) ;
35727 0 : SgOmpOrderedDependStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35728 : SgOmpOrderedDependStatementStorageClass* storageArray = storageArraySgOmpOrderedDependStatement;
35729 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35730 : {
35731 0 : SgOmpOrderedDependStatement* tmp = new SgOmpOrderedDependStatement ( *storageArray ) ;
35732 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35733 0 : storageArray++ ;
35734 : }
35735 : }
35736 0 : delete [] storageArraySgOmpOrderedDependStatement;
35737 2 : SgOmpOrderedDependStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35738 :
35739 :
35740 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirSpmdStatement );
35741 2 : SgUpirSpmdStatementStorageClass* storageArraySgUpirSpmdStatement = NULL;
35742 2 : if ( 0 < sizeOfActualPool )
35743 : {
35744 0 : storageArraySgUpirSpmdStatement = new SgUpirSpmdStatementStorageClass[sizeOfActualPool] ;
35745 0 : inFile.read ( (char*) (storageArraySgUpirSpmdStatement) , sizeof ( SgUpirSpmdStatementStorageClass ) * sizeOfActualPool) ;
35746 0 : SgUpirSpmdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35747 : SgUpirSpmdStatementStorageClass* storageArray = storageArraySgUpirSpmdStatement;
35748 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35749 : {
35750 0 : SgUpirSpmdStatement* tmp = new SgUpirSpmdStatement ( *storageArray ) ;
35751 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35752 0 : storageArray++ ;
35753 : }
35754 : }
35755 0 : delete [] storageArraySgUpirSpmdStatement;
35756 2 : SgUpirSpmdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35757 :
35758 :
35759 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsStatement );
35760 2 : SgOmpTeamsStatementStorageClass* storageArraySgOmpTeamsStatement = NULL;
35761 2 : if ( 0 < sizeOfActualPool )
35762 : {
35763 0 : storageArraySgOmpTeamsStatement = new SgOmpTeamsStatementStorageClass[sizeOfActualPool] ;
35764 0 : inFile.read ( (char*) (storageArraySgOmpTeamsStatement) , sizeof ( SgOmpTeamsStatementStorageClass ) * sizeOfActualPool) ;
35765 0 : SgOmpTeamsStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35766 : SgOmpTeamsStatementStorageClass* storageArray = storageArraySgOmpTeamsStatement;
35767 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35768 : {
35769 0 : SgOmpTeamsStatement* tmp = new SgOmpTeamsStatement ( *storageArray ) ;
35770 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35771 0 : storageArray++ ;
35772 : }
35773 : }
35774 0 : delete [] storageArraySgOmpTeamsStatement;
35775 2 : SgOmpTeamsStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35776 :
35777 :
35778 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCancellationPointStatement );
35779 2 : SgOmpCancellationPointStatementStorageClass* storageArraySgOmpCancellationPointStatement = NULL;
35780 2 : if ( 0 < sizeOfActualPool )
35781 : {
35782 0 : storageArraySgOmpCancellationPointStatement = new SgOmpCancellationPointStatementStorageClass[sizeOfActualPool] ;
35783 0 : inFile.read ( (char*) (storageArraySgOmpCancellationPointStatement) , sizeof ( SgOmpCancellationPointStatementStorageClass ) * sizeOfActualPool) ;
35784 0 : SgOmpCancellationPointStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35785 : SgOmpCancellationPointStatementStorageClass* storageArray = storageArraySgOmpCancellationPointStatement;
35786 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35787 : {
35788 0 : SgOmpCancellationPointStatement* tmp = new SgOmpCancellationPointStatement ( *storageArray ) ;
35789 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35790 0 : storageArray++ ;
35791 : }
35792 : }
35793 0 : delete [] storageArraySgOmpCancellationPointStatement;
35794 2 : SgOmpCancellationPointStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35795 :
35796 :
35797 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDeclareMapperStatement );
35798 2 : SgOmpDeclareMapperStatementStorageClass* storageArraySgOmpDeclareMapperStatement = NULL;
35799 2 : if ( 0 < sizeOfActualPool )
35800 : {
35801 0 : storageArraySgOmpDeclareMapperStatement = new SgOmpDeclareMapperStatementStorageClass[sizeOfActualPool] ;
35802 0 : inFile.read ( (char*) (storageArraySgOmpDeclareMapperStatement) , sizeof ( SgOmpDeclareMapperStatementStorageClass ) * sizeOfActualPool) ;
35803 0 : SgOmpDeclareMapperStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35804 : SgOmpDeclareMapperStatementStorageClass* storageArray = storageArraySgOmpDeclareMapperStatement;
35805 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35806 : {
35807 0 : SgOmpDeclareMapperStatement* tmp = new SgOmpDeclareMapperStatement ( *storageArray ) ;
35808 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35809 0 : storageArray++ ;
35810 : }
35811 : }
35812 0 : delete [] storageArraySgOmpDeclareMapperStatement;
35813 2 : SgOmpDeclareMapperStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35814 :
35815 :
35816 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCancelStatement );
35817 2 : SgOmpCancelStatementStorageClass* storageArraySgOmpCancelStatement = NULL;
35818 2 : if ( 0 < sizeOfActualPool )
35819 : {
35820 0 : storageArraySgOmpCancelStatement = new SgOmpCancelStatementStorageClass[sizeOfActualPool] ;
35821 0 : inFile.read ( (char*) (storageArraySgOmpCancelStatement) , sizeof ( SgOmpCancelStatementStorageClass ) * sizeOfActualPool) ;
35822 0 : SgOmpCancelStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35823 : SgOmpCancelStatementStorageClass* storageArray = storageArraySgOmpCancelStatement;
35824 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35825 : {
35826 0 : SgOmpCancelStatement* tmp = new SgOmpCancelStatement ( *storageArray ) ;
35827 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35828 0 : storageArray++ ;
35829 : }
35830 : }
35831 0 : delete [] storageArraySgOmpCancelStatement;
35832 2 : SgOmpCancelStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35833 :
35834 :
35835 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskgroupStatement );
35836 2 : SgOmpTaskgroupStatementStorageClass* storageArraySgOmpTaskgroupStatement = NULL;
35837 2 : if ( 0 < sizeOfActualPool )
35838 : {
35839 0 : storageArraySgOmpTaskgroupStatement = new SgOmpTaskgroupStatementStorageClass[sizeOfActualPool] ;
35840 0 : inFile.read ( (char*) (storageArraySgOmpTaskgroupStatement) , sizeof ( SgOmpTaskgroupStatementStorageClass ) * sizeOfActualPool) ;
35841 0 : SgOmpTaskgroupStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35842 : SgOmpTaskgroupStatementStorageClass* storageArray = storageArraySgOmpTaskgroupStatement;
35843 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35844 : {
35845 0 : SgOmpTaskgroupStatement* tmp = new SgOmpTaskgroupStatement ( *storageArray ) ;
35846 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35847 0 : storageArray++ ;
35848 : }
35849 : }
35850 0 : delete [] storageArraySgOmpTaskgroupStatement;
35851 2 : SgOmpTaskgroupStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35852 :
35853 :
35854 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDepobjStatement );
35855 2 : SgOmpDepobjStatementStorageClass* storageArraySgOmpDepobjStatement = NULL;
35856 2 : if ( 0 < sizeOfActualPool )
35857 : {
35858 0 : storageArraySgOmpDepobjStatement = new SgOmpDepobjStatementStorageClass[sizeOfActualPool] ;
35859 0 : inFile.read ( (char*) (storageArraySgOmpDepobjStatement) , sizeof ( SgOmpDepobjStatementStorageClass ) * sizeOfActualPool) ;
35860 0 : SgOmpDepobjStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35861 : SgOmpDepobjStatementStorageClass* storageArray = storageArraySgOmpDepobjStatement;
35862 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35863 : {
35864 0 : SgOmpDepobjStatement* tmp = new SgOmpDepobjStatement ( *storageArray ) ;
35865 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35866 0 : storageArray++ ;
35867 : }
35868 : }
35869 0 : delete [] storageArraySgOmpDepobjStatement;
35870 2 : SgOmpDepobjStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35871 :
35872 :
35873 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDistributeStatement );
35874 2 : SgOmpDistributeStatementStorageClass* storageArraySgOmpDistributeStatement = NULL;
35875 2 : if ( 0 < sizeOfActualPool )
35876 : {
35877 0 : storageArraySgOmpDistributeStatement = new SgOmpDistributeStatementStorageClass[sizeOfActualPool] ;
35878 0 : inFile.read ( (char*) (storageArraySgOmpDistributeStatement) , sizeof ( SgOmpDistributeStatementStorageClass ) * sizeOfActualPool) ;
35879 0 : SgOmpDistributeStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35880 : SgOmpDistributeStatementStorageClass* storageArray = storageArraySgOmpDistributeStatement;
35881 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35882 : {
35883 0 : SgOmpDistributeStatement* tmp = new SgOmpDistributeStatement ( *storageArray ) ;
35884 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35885 0 : storageArray++ ;
35886 : }
35887 : }
35888 0 : delete [] storageArraySgOmpDistributeStatement;
35889 2 : SgOmpDistributeStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35890 :
35891 :
35892 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpLoopStatement );
35893 2 : SgOmpLoopStatementStorageClass* storageArraySgOmpLoopStatement = NULL;
35894 2 : if ( 0 < sizeOfActualPool )
35895 : {
35896 0 : storageArraySgOmpLoopStatement = new SgOmpLoopStatementStorageClass[sizeOfActualPool] ;
35897 0 : inFile.read ( (char*) (storageArraySgOmpLoopStatement) , sizeof ( SgOmpLoopStatementStorageClass ) * sizeOfActualPool) ;
35898 0 : SgOmpLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35899 : SgOmpLoopStatementStorageClass* storageArray = storageArraySgOmpLoopStatement;
35900 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35901 : {
35902 0 : SgOmpLoopStatement* tmp = new SgOmpLoopStatement ( *storageArray ) ;
35903 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35904 0 : storageArray++ ;
35905 : }
35906 : }
35907 0 : delete [] storageArraySgOmpLoopStatement;
35908 2 : SgOmpLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35909 :
35910 :
35911 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpScanStatement );
35912 2 : SgOmpScanStatementStorageClass* storageArraySgOmpScanStatement = NULL;
35913 2 : if ( 0 < sizeOfActualPool )
35914 : {
35915 0 : storageArraySgOmpScanStatement = new SgOmpScanStatementStorageClass[sizeOfActualPool] ;
35916 0 : inFile.read ( (char*) (storageArraySgOmpScanStatement) , sizeof ( SgOmpScanStatementStorageClass ) * sizeOfActualPool) ;
35917 0 : SgOmpScanStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35918 : SgOmpScanStatementStorageClass* storageArray = storageArraySgOmpScanStatement;
35919 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35920 : {
35921 0 : SgOmpScanStatement* tmp = new SgOmpScanStatement ( *storageArray ) ;
35922 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35923 0 : storageArray++ ;
35924 : }
35925 : }
35926 0 : delete [] storageArraySgOmpScanStatement;
35927 2 : SgOmpScanStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35928 :
35929 :
35930 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskloopStatement );
35931 2 : SgOmpTaskloopStatementStorageClass* storageArraySgOmpTaskloopStatement = NULL;
35932 2 : if ( 0 < sizeOfActualPool )
35933 : {
35934 0 : storageArraySgOmpTaskloopStatement = new SgOmpTaskloopStatementStorageClass[sizeOfActualPool] ;
35935 0 : inFile.read ( (char*) (storageArraySgOmpTaskloopStatement) , sizeof ( SgOmpTaskloopStatementStorageClass ) * sizeOfActualPool) ;
35936 0 : SgOmpTaskloopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35937 : SgOmpTaskloopStatementStorageClass* storageArray = storageArraySgOmpTaskloopStatement;
35938 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35939 : {
35940 0 : SgOmpTaskloopStatement* tmp = new SgOmpTaskloopStatement ( *storageArray ) ;
35941 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35942 0 : storageArray++ ;
35943 : }
35944 : }
35945 0 : delete [] storageArraySgOmpTaskloopStatement;
35946 2 : SgOmpTaskloopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35947 :
35948 :
35949 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetEnterDataStatement );
35950 2 : SgOmpTargetEnterDataStatementStorageClass* storageArraySgOmpTargetEnterDataStatement = NULL;
35951 2 : if ( 0 < sizeOfActualPool )
35952 : {
35953 0 : storageArraySgOmpTargetEnterDataStatement = new SgOmpTargetEnterDataStatementStorageClass[sizeOfActualPool] ;
35954 0 : inFile.read ( (char*) (storageArraySgOmpTargetEnterDataStatement) , sizeof ( SgOmpTargetEnterDataStatementStorageClass ) * sizeOfActualPool) ;
35955 0 : SgOmpTargetEnterDataStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35956 : SgOmpTargetEnterDataStatementStorageClass* storageArray = storageArraySgOmpTargetEnterDataStatement;
35957 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35958 : {
35959 0 : SgOmpTargetEnterDataStatement* tmp = new SgOmpTargetEnterDataStatement ( *storageArray ) ;
35960 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35961 0 : storageArray++ ;
35962 : }
35963 : }
35964 0 : delete [] storageArraySgOmpTargetEnterDataStatement;
35965 2 : SgOmpTargetEnterDataStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35966 :
35967 :
35968 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetExitDataStatement );
35969 2 : SgOmpTargetExitDataStatementStorageClass* storageArraySgOmpTargetExitDataStatement = NULL;
35970 2 : if ( 0 < sizeOfActualPool )
35971 : {
35972 0 : storageArraySgOmpTargetExitDataStatement = new SgOmpTargetExitDataStatementStorageClass[sizeOfActualPool] ;
35973 0 : inFile.read ( (char*) (storageArraySgOmpTargetExitDataStatement) , sizeof ( SgOmpTargetExitDataStatementStorageClass ) * sizeOfActualPool) ;
35974 0 : SgOmpTargetExitDataStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35975 : SgOmpTargetExitDataStatementStorageClass* storageArray = storageArraySgOmpTargetExitDataStatement;
35976 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35977 : {
35978 0 : SgOmpTargetExitDataStatement* tmp = new SgOmpTargetExitDataStatement ( *storageArray ) ;
35979 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35980 0 : storageArray++ ;
35981 : }
35982 : }
35983 0 : delete [] storageArraySgOmpTargetExitDataStatement;
35984 2 : SgOmpTargetExitDataStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
35985 :
35986 :
35987 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSectionStatement );
35988 2 : SgOmpSectionStatementStorageClass* storageArraySgOmpSectionStatement = NULL;
35989 2 : if ( 0 < sizeOfActualPool )
35990 : {
35991 0 : storageArraySgOmpSectionStatement = new SgOmpSectionStatementStorageClass[sizeOfActualPool] ;
35992 0 : inFile.read ( (char*) (storageArraySgOmpSectionStatement) , sizeof ( SgOmpSectionStatementStorageClass ) * sizeOfActualPool) ;
35993 0 : SgOmpSectionStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
35994 : SgOmpSectionStatementStorageClass* storageArray = storageArraySgOmpSectionStatement;
35995 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
35996 : {
35997 0 : SgOmpSectionStatement* tmp = new SgOmpSectionStatement ( *storageArray ) ;
35998 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
35999 0 : storageArray++ ;
36000 : }
36001 : }
36002 0 : delete [] storageArraySgOmpSectionStatement;
36003 2 : SgOmpSectionStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36004 :
36005 :
36006 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSectionsStatement );
36007 2 : SgOmpSectionsStatementStorageClass* storageArraySgOmpSectionsStatement = NULL;
36008 2 : if ( 0 < sizeOfActualPool )
36009 : {
36010 0 : storageArraySgOmpSectionsStatement = new SgOmpSectionsStatementStorageClass[sizeOfActualPool] ;
36011 0 : inFile.read ( (char*) (storageArraySgOmpSectionsStatement) , sizeof ( SgOmpSectionsStatementStorageClass ) * sizeOfActualPool) ;
36012 0 : SgOmpSectionsStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36013 : SgOmpSectionsStatementStorageClass* storageArray = storageArraySgOmpSectionsStatement;
36014 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36015 : {
36016 0 : SgOmpSectionsStatement* tmp = new SgOmpSectionsStatement ( *storageArray ) ;
36017 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36018 0 : storageArray++ ;
36019 : }
36020 : }
36021 0 : delete [] storageArraySgOmpSectionsStatement;
36022 2 : SgOmpSectionsStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36023 :
36024 :
36025 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSingleStatement );
36026 2 : SgOmpSingleStatementStorageClass* storageArraySgOmpSingleStatement = NULL;
36027 2 : if ( 0 < sizeOfActualPool )
36028 : {
36029 0 : storageArraySgOmpSingleStatement = new SgOmpSingleStatementStorageClass[sizeOfActualPool] ;
36030 0 : inFile.read ( (char*) (storageArraySgOmpSingleStatement) , sizeof ( SgOmpSingleStatementStorageClass ) * sizeOfActualPool) ;
36031 0 : SgOmpSingleStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36032 : SgOmpSingleStatementStorageClass* storageArray = storageArraySgOmpSingleStatement;
36033 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36034 : {
36035 0 : SgOmpSingleStatement* tmp = new SgOmpSingleStatement ( *storageArray ) ;
36036 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36037 0 : storageArray++ ;
36038 : }
36039 : }
36040 0 : delete [] storageArraySgOmpSingleStatement;
36041 2 : SgOmpSingleStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36042 :
36043 :
36044 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskStatement );
36045 2 : SgOmpTaskStatementStorageClass* storageArraySgOmpTaskStatement = NULL;
36046 2 : if ( 0 < sizeOfActualPool )
36047 : {
36048 0 : storageArraySgOmpTaskStatement = new SgOmpTaskStatementStorageClass[sizeOfActualPool] ;
36049 0 : inFile.read ( (char*) (storageArraySgOmpTaskStatement) , sizeof ( SgOmpTaskStatementStorageClass ) * sizeOfActualPool) ;
36050 0 : SgOmpTaskStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36051 : SgOmpTaskStatementStorageClass* storageArray = storageArraySgOmpTaskStatement;
36052 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36053 : {
36054 0 : SgOmpTaskStatement* tmp = new SgOmpTaskStatement ( *storageArray ) ;
36055 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36056 0 : storageArray++ ;
36057 : }
36058 : }
36059 0 : delete [] storageArraySgOmpTaskStatement;
36060 2 : SgOmpTaskStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36061 :
36062 :
36063 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskwaitStatement );
36064 2 : SgOmpTaskwaitStatementStorageClass* storageArraySgOmpTaskwaitStatement = NULL;
36065 2 : if ( 0 < sizeOfActualPool )
36066 : {
36067 0 : storageArraySgOmpTaskwaitStatement = new SgOmpTaskwaitStatementStorageClass[sizeOfActualPool] ;
36068 0 : inFile.read ( (char*) (storageArraySgOmpTaskwaitStatement) , sizeof ( SgOmpTaskwaitStatementStorageClass ) * sizeOfActualPool) ;
36069 0 : SgOmpTaskwaitStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36070 : SgOmpTaskwaitStatementStorageClass* storageArray = storageArraySgOmpTaskwaitStatement;
36071 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36072 : {
36073 0 : SgOmpTaskwaitStatement* tmp = new SgOmpTaskwaitStatement ( *storageArray ) ;
36074 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36075 0 : storageArray++ ;
36076 : }
36077 : }
36078 0 : delete [] storageArraySgOmpTaskwaitStatement;
36079 2 : SgOmpTaskwaitStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36080 :
36081 :
36082 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpThreadprivateStatement );
36083 2 : SgOmpThreadprivateStatementStorageClass* storageArraySgOmpThreadprivateStatement = NULL;
36084 2 : if ( 0 < sizeOfActualPool )
36085 : {
36086 0 : storageArraySgOmpThreadprivateStatement = new SgOmpThreadprivateStatementStorageClass[sizeOfActualPool] ;
36087 0 : inFile.read ( (char*) (storageArraySgOmpThreadprivateStatement) , sizeof ( SgOmpThreadprivateStatementStorageClass ) * sizeOfActualPool) ;
36088 0 : SgOmpThreadprivateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36089 : SgOmpThreadprivateStatementStorageClass* storageArray = storageArraySgOmpThreadprivateStatement;
36090 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36091 : {
36092 0 : SgOmpThreadprivateStatement* tmp = new SgOmpThreadprivateStatement ( *storageArray ) ;
36093 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36094 0 : storageArray++ ;
36095 : }
36096 : }
36097 0 : delete [] storageArraySgOmpThreadprivateStatement;
36098 2 : SgOmpThreadprivateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36099 :
36100 :
36101 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpWorkshareStatement );
36102 2 : SgOmpWorkshareStatementStorageClass* storageArraySgOmpWorkshareStatement = NULL;
36103 2 : if ( 0 < sizeOfActualPool )
36104 : {
36105 0 : storageArraySgOmpWorkshareStatement = new SgOmpWorkshareStatementStorageClass[sizeOfActualPool] ;
36106 0 : inFile.read ( (char*) (storageArraySgOmpWorkshareStatement) , sizeof ( SgOmpWorkshareStatementStorageClass ) * sizeOfActualPool) ;
36107 0 : SgOmpWorkshareStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36108 : SgOmpWorkshareStatementStorageClass* storageArray = storageArraySgOmpWorkshareStatement;
36109 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36110 : {
36111 0 : SgOmpWorkshareStatement* tmp = new SgOmpWorkshareStatement ( *storageArray ) ;
36112 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36113 0 : storageArray++ ;
36114 : }
36115 : }
36116 0 : delete [] storageArraySgOmpWorkshareStatement;
36117 2 : SgOmpWorkshareStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36118 :
36119 :
36120 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirTaskStatement );
36121 2 : SgUpirTaskStatementStorageClass* storageArraySgUpirTaskStatement = NULL;
36122 2 : if ( 0 < sizeOfActualPool )
36123 : {
36124 0 : storageArraySgUpirTaskStatement = new SgUpirTaskStatementStorageClass[sizeOfActualPool] ;
36125 0 : inFile.read ( (char*) (storageArraySgUpirTaskStatement) , sizeof ( SgUpirTaskStatementStorageClass ) * sizeOfActualPool) ;
36126 0 : SgUpirTaskStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36127 : SgUpirTaskStatementStorageClass* storageArray = storageArraySgUpirTaskStatement;
36128 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36129 : {
36130 0 : SgUpirTaskStatement* tmp = new SgUpirTaskStatement ( *storageArray ) ;
36131 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36132 0 : storageArray++ ;
36133 : }
36134 : }
36135 0 : delete [] storageArraySgUpirTaskStatement;
36136 2 : SgUpirTaskStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36137 :
36138 :
36139 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetDataStatement );
36140 2 : SgOmpTargetDataStatementStorageClass* storageArraySgOmpTargetDataStatement = NULL;
36141 2 : if ( 0 < sizeOfActualPool )
36142 : {
36143 0 : storageArraySgOmpTargetDataStatement = new SgOmpTargetDataStatementStorageClass[sizeOfActualPool] ;
36144 0 : inFile.read ( (char*) (storageArraySgOmpTargetDataStatement) , sizeof ( SgOmpTargetDataStatementStorageClass ) * sizeOfActualPool) ;
36145 0 : SgOmpTargetDataStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36146 : SgOmpTargetDataStatementStorageClass* storageArray = storageArraySgOmpTargetDataStatement;
36147 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36148 : {
36149 0 : SgOmpTargetDataStatement* tmp = new SgOmpTargetDataStatement ( *storageArray ) ;
36150 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36151 0 : storageArray++ ;
36152 : }
36153 : }
36154 0 : delete [] storageArraySgOmpTargetDataStatement;
36155 2 : SgOmpTargetDataStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36156 :
36157 :
36158 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetParallelForStatement );
36159 2 : SgOmpTargetParallelForStatementStorageClass* storageArraySgOmpTargetParallelForStatement = NULL;
36160 2 : if ( 0 < sizeOfActualPool )
36161 : {
36162 0 : storageArraySgOmpTargetParallelForStatement = new SgOmpTargetParallelForStatementStorageClass[sizeOfActualPool] ;
36163 0 : inFile.read ( (char*) (storageArraySgOmpTargetParallelForStatement) , sizeof ( SgOmpTargetParallelForStatementStorageClass ) * sizeOfActualPool) ;
36164 0 : SgOmpTargetParallelForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36165 : SgOmpTargetParallelForStatementStorageClass* storageArray = storageArraySgOmpTargetParallelForStatement;
36166 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36167 : {
36168 0 : SgOmpTargetParallelForStatement* tmp = new SgOmpTargetParallelForStatement ( *storageArray ) ;
36169 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36170 0 : storageArray++ ;
36171 : }
36172 : }
36173 0 : delete [] storageArraySgOmpTargetParallelForStatement;
36174 2 : SgOmpTargetParallelForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36175 :
36176 :
36177 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetUpdateStatement );
36178 2 : SgOmpTargetUpdateStatementStorageClass* storageArraySgOmpTargetUpdateStatement = NULL;
36179 2 : if ( 0 < sizeOfActualPool )
36180 : {
36181 0 : storageArraySgOmpTargetUpdateStatement = new SgOmpTargetUpdateStatementStorageClass[sizeOfActualPool] ;
36182 0 : inFile.read ( (char*) (storageArraySgOmpTargetUpdateStatement) , sizeof ( SgOmpTargetUpdateStatementStorageClass ) * sizeOfActualPool) ;
36183 0 : SgOmpTargetUpdateStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36184 : SgOmpTargetUpdateStatementStorageClass* storageArray = storageArraySgOmpTargetUpdateStatement;
36185 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36186 : {
36187 0 : SgOmpTargetUpdateStatement* tmp = new SgOmpTargetUpdateStatement ( *storageArray ) ;
36188 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36189 0 : storageArray++ ;
36190 : }
36191 : }
36192 0 : delete [] storageArraySgOmpTargetUpdateStatement;
36193 2 : SgOmpTargetUpdateStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36194 :
36195 :
36196 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpRequiresStatement );
36197 2 : SgOmpRequiresStatementStorageClass* storageArraySgOmpRequiresStatement = NULL;
36198 2 : if ( 0 < sizeOfActualPool )
36199 : {
36200 0 : storageArraySgOmpRequiresStatement = new SgOmpRequiresStatementStorageClass[sizeOfActualPool] ;
36201 0 : inFile.read ( (char*) (storageArraySgOmpRequiresStatement) , sizeof ( SgOmpRequiresStatementStorageClass ) * sizeOfActualPool) ;
36202 0 : SgOmpRequiresStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36203 : SgOmpRequiresStatementStorageClass* storageArray = storageArraySgOmpRequiresStatement;
36204 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36205 : {
36206 0 : SgOmpRequiresStatement* tmp = new SgOmpRequiresStatement ( *storageArray ) ;
36207 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36208 0 : storageArray++ ;
36209 : }
36210 : }
36211 0 : delete [] storageArraySgOmpRequiresStatement;
36212 2 : SgOmpRequiresStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36213 :
36214 :
36215 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetParallelStatement );
36216 2 : SgOmpTargetParallelStatementStorageClass* storageArraySgOmpTargetParallelStatement = NULL;
36217 2 : if ( 0 < sizeOfActualPool )
36218 : {
36219 0 : storageArraySgOmpTargetParallelStatement = new SgOmpTargetParallelStatementStorageClass[sizeOfActualPool] ;
36220 0 : inFile.read ( (char*) (storageArraySgOmpTargetParallelStatement) , sizeof ( SgOmpTargetParallelStatementStorageClass ) * sizeOfActualPool) ;
36221 0 : SgOmpTargetParallelStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36222 : SgOmpTargetParallelStatementStorageClass* storageArray = storageArraySgOmpTargetParallelStatement;
36223 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36224 : {
36225 0 : SgOmpTargetParallelStatement* tmp = new SgOmpTargetParallelStatement ( *storageArray ) ;
36226 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36227 0 : storageArray++ ;
36228 : }
36229 : }
36230 0 : delete [] storageArraySgOmpTargetParallelStatement;
36231 2 : SgOmpTargetParallelStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36232 :
36233 :
36234 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetParallelForSimdStatement );
36235 2 : SgOmpTargetParallelForSimdStatementStorageClass* storageArraySgOmpTargetParallelForSimdStatement = NULL;
36236 2 : if ( 0 < sizeOfActualPool )
36237 : {
36238 0 : storageArraySgOmpTargetParallelForSimdStatement = new SgOmpTargetParallelForSimdStatementStorageClass[sizeOfActualPool] ;
36239 0 : inFile.read ( (char*) (storageArraySgOmpTargetParallelForSimdStatement) , sizeof ( SgOmpTargetParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
36240 0 : SgOmpTargetParallelForSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36241 : SgOmpTargetParallelForSimdStatementStorageClass* storageArray = storageArraySgOmpTargetParallelForSimdStatement;
36242 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36243 : {
36244 0 : SgOmpTargetParallelForSimdStatement* tmp = new SgOmpTargetParallelForSimdStatement ( *storageArray ) ;
36245 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36246 0 : storageArray++ ;
36247 : }
36248 : }
36249 0 : delete [] storageArraySgOmpTargetParallelForSimdStatement;
36250 2 : SgOmpTargetParallelForSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36251 :
36252 :
36253 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetParallelLoopStatement );
36254 2 : SgOmpTargetParallelLoopStatementStorageClass* storageArraySgOmpTargetParallelLoopStatement = NULL;
36255 2 : if ( 0 < sizeOfActualPool )
36256 : {
36257 0 : storageArraySgOmpTargetParallelLoopStatement = new SgOmpTargetParallelLoopStatementStorageClass[sizeOfActualPool] ;
36258 0 : inFile.read ( (char*) (storageArraySgOmpTargetParallelLoopStatement) , sizeof ( SgOmpTargetParallelLoopStatementStorageClass ) * sizeOfActualPool) ;
36259 0 : SgOmpTargetParallelLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36260 : SgOmpTargetParallelLoopStatementStorageClass* storageArray = storageArraySgOmpTargetParallelLoopStatement;
36261 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36262 : {
36263 0 : SgOmpTargetParallelLoopStatement* tmp = new SgOmpTargetParallelLoopStatement ( *storageArray ) ;
36264 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36265 0 : storageArray++ ;
36266 : }
36267 : }
36268 0 : delete [] storageArraySgOmpTargetParallelLoopStatement;
36269 2 : SgOmpTargetParallelLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36270 :
36271 :
36272 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetSimdStatement );
36273 2 : SgOmpTargetSimdStatementStorageClass* storageArraySgOmpTargetSimdStatement = NULL;
36274 2 : if ( 0 < sizeOfActualPool )
36275 : {
36276 0 : storageArraySgOmpTargetSimdStatement = new SgOmpTargetSimdStatementStorageClass[sizeOfActualPool] ;
36277 0 : inFile.read ( (char*) (storageArraySgOmpTargetSimdStatement) , sizeof ( SgOmpTargetSimdStatementStorageClass ) * sizeOfActualPool) ;
36278 0 : SgOmpTargetSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36279 : SgOmpTargetSimdStatementStorageClass* storageArray = storageArraySgOmpTargetSimdStatement;
36280 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36281 : {
36282 0 : SgOmpTargetSimdStatement* tmp = new SgOmpTargetSimdStatement ( *storageArray ) ;
36283 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36284 0 : storageArray++ ;
36285 : }
36286 : }
36287 0 : delete [] storageArraySgOmpTargetSimdStatement;
36288 2 : SgOmpTargetSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36289 :
36290 :
36291 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsStatement );
36292 2 : SgOmpTargetTeamsStatementStorageClass* storageArraySgOmpTargetTeamsStatement = NULL;
36293 2 : if ( 0 < sizeOfActualPool )
36294 : {
36295 0 : storageArraySgOmpTargetTeamsStatement = new SgOmpTargetTeamsStatementStorageClass[sizeOfActualPool] ;
36296 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsStatement) , sizeof ( SgOmpTargetTeamsStatementStorageClass ) * sizeOfActualPool) ;
36297 0 : SgOmpTargetTeamsStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36298 : SgOmpTargetTeamsStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsStatement;
36299 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36300 : {
36301 0 : SgOmpTargetTeamsStatement* tmp = new SgOmpTargetTeamsStatement ( *storageArray ) ;
36302 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36303 0 : storageArray++ ;
36304 : }
36305 : }
36306 0 : delete [] storageArraySgOmpTargetTeamsStatement;
36307 2 : SgOmpTargetTeamsStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36308 :
36309 :
36310 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsDistributeStatement );
36311 2 : SgOmpTargetTeamsDistributeStatementStorageClass* storageArraySgOmpTargetTeamsDistributeStatement = NULL;
36312 2 : if ( 0 < sizeOfActualPool )
36313 : {
36314 0 : storageArraySgOmpTargetTeamsDistributeStatement = new SgOmpTargetTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
36315 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsDistributeStatement) , sizeof ( SgOmpTargetTeamsDistributeStatementStorageClass ) * sizeOfActualPool) ;
36316 0 : SgOmpTargetTeamsDistributeStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36317 : SgOmpTargetTeamsDistributeStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsDistributeStatement;
36318 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36319 : {
36320 0 : SgOmpTargetTeamsDistributeStatement* tmp = new SgOmpTargetTeamsDistributeStatement ( *storageArray ) ;
36321 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36322 0 : storageArray++ ;
36323 : }
36324 : }
36325 0 : delete [] storageArraySgOmpTargetTeamsDistributeStatement;
36326 2 : SgOmpTargetTeamsDistributeStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36327 :
36328 :
36329 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsDistributeSimdStatement );
36330 2 : SgOmpTargetTeamsDistributeSimdStatementStorageClass* storageArraySgOmpTargetTeamsDistributeSimdStatement = NULL;
36331 2 : if ( 0 < sizeOfActualPool )
36332 : {
36333 0 : storageArraySgOmpTargetTeamsDistributeSimdStatement = new SgOmpTargetTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
36334 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsDistributeSimdStatement) , sizeof ( SgOmpTargetTeamsDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
36335 0 : SgOmpTargetTeamsDistributeSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36336 : SgOmpTargetTeamsDistributeSimdStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsDistributeSimdStatement;
36337 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36338 : {
36339 0 : SgOmpTargetTeamsDistributeSimdStatement* tmp = new SgOmpTargetTeamsDistributeSimdStatement ( *storageArray ) ;
36340 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36341 0 : storageArray++ ;
36342 : }
36343 : }
36344 0 : delete [] storageArraySgOmpTargetTeamsDistributeSimdStatement;
36345 2 : SgOmpTargetTeamsDistributeSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36346 :
36347 :
36348 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsLoopStatement );
36349 2 : SgOmpTargetTeamsLoopStatementStorageClass* storageArraySgOmpTargetTeamsLoopStatement = NULL;
36350 2 : if ( 0 < sizeOfActualPool )
36351 : {
36352 0 : storageArraySgOmpTargetTeamsLoopStatement = new SgOmpTargetTeamsLoopStatementStorageClass[sizeOfActualPool] ;
36353 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsLoopStatement) , sizeof ( SgOmpTargetTeamsLoopStatementStorageClass ) * sizeOfActualPool) ;
36354 0 : SgOmpTargetTeamsLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36355 : SgOmpTargetTeamsLoopStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsLoopStatement;
36356 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36357 : {
36358 0 : SgOmpTargetTeamsLoopStatement* tmp = new SgOmpTargetTeamsLoopStatement ( *storageArray ) ;
36359 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36360 0 : storageArray++ ;
36361 : }
36362 : }
36363 0 : delete [] storageArraySgOmpTargetTeamsLoopStatement;
36364 2 : SgOmpTargetTeamsLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36365 :
36366 :
36367 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsDistributeParallelForStatement );
36368 2 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass* storageArraySgOmpTargetTeamsDistributeParallelForStatement = NULL;
36369 2 : if ( 0 < sizeOfActualPool )
36370 : {
36371 0 : storageArraySgOmpTargetTeamsDistributeParallelForStatement = new SgOmpTargetTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
36372 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsDistributeParallelForStatement) , sizeof ( SgOmpTargetTeamsDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
36373 0 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36374 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsDistributeParallelForStatement;
36375 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36376 : {
36377 0 : SgOmpTargetTeamsDistributeParallelForStatement* tmp = new SgOmpTargetTeamsDistributeParallelForStatement ( *storageArray ) ;
36378 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36379 0 : storageArray++ ;
36380 : }
36381 : }
36382 0 : delete [] storageArraySgOmpTargetTeamsDistributeParallelForStatement;
36383 2 : SgOmpTargetTeamsDistributeParallelForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36384 :
36385 :
36386 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTargetTeamsDistributeParallelForSimdStatement );
36387 2 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass* storageArraySgOmpTargetTeamsDistributeParallelForSimdStatement = NULL;
36388 2 : if ( 0 < sizeOfActualPool )
36389 : {
36390 0 : storageArraySgOmpTargetTeamsDistributeParallelForSimdStatement = new SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
36391 0 : inFile.read ( (char*) (storageArraySgOmpTargetTeamsDistributeParallelForSimdStatement) , sizeof ( SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
36392 0 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36393 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass* storageArray = storageArraySgOmpTargetTeamsDistributeParallelForSimdStatement;
36394 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36395 : {
36396 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement* tmp = new SgOmpTargetTeamsDistributeParallelForSimdStatement ( *storageArray ) ;
36397 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36398 0 : storageArray++ ;
36399 : }
36400 : }
36401 0 : delete [] storageArraySgOmpTargetTeamsDistributeParallelForSimdStatement;
36402 2 : SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36403 :
36404 :
36405 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDistributeSimdStatement );
36406 2 : SgOmpDistributeSimdStatementStorageClass* storageArraySgOmpDistributeSimdStatement = NULL;
36407 2 : if ( 0 < sizeOfActualPool )
36408 : {
36409 0 : storageArraySgOmpDistributeSimdStatement = new SgOmpDistributeSimdStatementStorageClass[sizeOfActualPool] ;
36410 0 : inFile.read ( (char*) (storageArraySgOmpDistributeSimdStatement) , sizeof ( SgOmpDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
36411 0 : SgOmpDistributeSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36412 : SgOmpDistributeSimdStatementStorageClass* storageArray = storageArraySgOmpDistributeSimdStatement;
36413 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36414 : {
36415 0 : SgOmpDistributeSimdStatement* tmp = new SgOmpDistributeSimdStatement ( *storageArray ) ;
36416 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36417 0 : storageArray++ ;
36418 : }
36419 : }
36420 0 : delete [] storageArraySgOmpDistributeSimdStatement;
36421 2 : SgOmpDistributeSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36422 :
36423 :
36424 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDistributeParallelForStatement );
36425 2 : SgOmpDistributeParallelForStatementStorageClass* storageArraySgOmpDistributeParallelForStatement = NULL;
36426 2 : if ( 0 < sizeOfActualPool )
36427 : {
36428 0 : storageArraySgOmpDistributeParallelForStatement = new SgOmpDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
36429 0 : inFile.read ( (char*) (storageArraySgOmpDistributeParallelForStatement) , sizeof ( SgOmpDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
36430 0 : SgOmpDistributeParallelForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36431 : SgOmpDistributeParallelForStatementStorageClass* storageArray = storageArraySgOmpDistributeParallelForStatement;
36432 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36433 : {
36434 0 : SgOmpDistributeParallelForStatement* tmp = new SgOmpDistributeParallelForStatement ( *storageArray ) ;
36435 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36436 0 : storageArray++ ;
36437 : }
36438 : }
36439 0 : delete [] storageArraySgOmpDistributeParallelForStatement;
36440 2 : SgOmpDistributeParallelForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36441 :
36442 :
36443 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDistributeParallelForSimdStatement );
36444 2 : SgOmpDistributeParallelForSimdStatementStorageClass* storageArraySgOmpDistributeParallelForSimdStatement = NULL;
36445 2 : if ( 0 < sizeOfActualPool )
36446 : {
36447 0 : storageArraySgOmpDistributeParallelForSimdStatement = new SgOmpDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
36448 0 : inFile.read ( (char*) (storageArraySgOmpDistributeParallelForSimdStatement) , sizeof ( SgOmpDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
36449 0 : SgOmpDistributeParallelForSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36450 : SgOmpDistributeParallelForSimdStatementStorageClass* storageArray = storageArraySgOmpDistributeParallelForSimdStatement;
36451 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36452 : {
36453 0 : SgOmpDistributeParallelForSimdStatement* tmp = new SgOmpDistributeParallelForSimdStatement ( *storageArray ) ;
36454 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36455 0 : storageArray++ ;
36456 : }
36457 : }
36458 0 : delete [] storageArraySgOmpDistributeParallelForSimdStatement;
36459 2 : SgOmpDistributeParallelForSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36460 :
36461 :
36462 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskloopSimdStatement );
36463 2 : SgOmpTaskloopSimdStatementStorageClass* storageArraySgOmpTaskloopSimdStatement = NULL;
36464 2 : if ( 0 < sizeOfActualPool )
36465 : {
36466 0 : storageArraySgOmpTaskloopSimdStatement = new SgOmpTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
36467 0 : inFile.read ( (char*) (storageArraySgOmpTaskloopSimdStatement) , sizeof ( SgOmpTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
36468 0 : SgOmpTaskloopSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36469 : SgOmpTaskloopSimdStatementStorageClass* storageArray = storageArraySgOmpTaskloopSimdStatement;
36470 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36471 : {
36472 0 : SgOmpTaskloopSimdStatement* tmp = new SgOmpTaskloopSimdStatement ( *storageArray ) ;
36473 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36474 0 : storageArray++ ;
36475 : }
36476 : }
36477 0 : delete [] storageArraySgOmpTaskloopSimdStatement;
36478 2 : SgOmpTaskloopSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36479 :
36480 :
36481 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMasterTaskloopSimdStatement );
36482 2 : SgOmpMasterTaskloopSimdStatementStorageClass* storageArraySgOmpMasterTaskloopSimdStatement = NULL;
36483 2 : if ( 0 < sizeOfActualPool )
36484 : {
36485 0 : storageArraySgOmpMasterTaskloopSimdStatement = new SgOmpMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
36486 0 : inFile.read ( (char*) (storageArraySgOmpMasterTaskloopSimdStatement) , sizeof ( SgOmpMasterTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
36487 0 : SgOmpMasterTaskloopSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36488 : SgOmpMasterTaskloopSimdStatementStorageClass* storageArray = storageArraySgOmpMasterTaskloopSimdStatement;
36489 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36490 : {
36491 0 : SgOmpMasterTaskloopSimdStatement* tmp = new SgOmpMasterTaskloopSimdStatement ( *storageArray ) ;
36492 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36493 0 : storageArray++ ;
36494 : }
36495 : }
36496 0 : delete [] storageArraySgOmpMasterTaskloopSimdStatement;
36497 2 : SgOmpMasterTaskloopSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36498 :
36499 :
36500 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpParallelMasterTaskloopStatement );
36501 2 : SgOmpParallelMasterTaskloopStatementStorageClass* storageArraySgOmpParallelMasterTaskloopStatement = NULL;
36502 2 : if ( 0 < sizeOfActualPool )
36503 : {
36504 0 : storageArraySgOmpParallelMasterTaskloopStatement = new SgOmpParallelMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
36505 0 : inFile.read ( (char*) (storageArraySgOmpParallelMasterTaskloopStatement) , sizeof ( SgOmpParallelMasterTaskloopStatementStorageClass ) * sizeOfActualPool) ;
36506 0 : SgOmpParallelMasterTaskloopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36507 : SgOmpParallelMasterTaskloopStatementStorageClass* storageArray = storageArraySgOmpParallelMasterTaskloopStatement;
36508 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36509 : {
36510 0 : SgOmpParallelMasterTaskloopStatement* tmp = new SgOmpParallelMasterTaskloopStatement ( *storageArray ) ;
36511 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36512 0 : storageArray++ ;
36513 : }
36514 : }
36515 0 : delete [] storageArraySgOmpParallelMasterTaskloopStatement;
36516 2 : SgOmpParallelMasterTaskloopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36517 :
36518 :
36519 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpParallelMasterTaskloopSimdStatement );
36520 2 : SgOmpParallelMasterTaskloopSimdStatementStorageClass* storageArraySgOmpParallelMasterTaskloopSimdStatement = NULL;
36521 2 : if ( 0 < sizeOfActualPool )
36522 : {
36523 0 : storageArraySgOmpParallelMasterTaskloopSimdStatement = new SgOmpParallelMasterTaskloopSimdStatementStorageClass[sizeOfActualPool] ;
36524 0 : inFile.read ( (char*) (storageArraySgOmpParallelMasterTaskloopSimdStatement) , sizeof ( SgOmpParallelMasterTaskloopSimdStatementStorageClass ) * sizeOfActualPool) ;
36525 0 : SgOmpParallelMasterTaskloopSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36526 : SgOmpParallelMasterTaskloopSimdStatementStorageClass* storageArray = storageArraySgOmpParallelMasterTaskloopSimdStatement;
36527 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36528 : {
36529 0 : SgOmpParallelMasterTaskloopSimdStatement* tmp = new SgOmpParallelMasterTaskloopSimdStatement ( *storageArray ) ;
36530 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36531 0 : storageArray++ ;
36532 : }
36533 : }
36534 0 : delete [] storageArraySgOmpParallelMasterTaskloopSimdStatement;
36535 2 : SgOmpParallelMasterTaskloopSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36536 :
36537 :
36538 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsDistributeStatement );
36539 2 : SgOmpTeamsDistributeStatementStorageClass* storageArraySgOmpTeamsDistributeStatement = NULL;
36540 2 : if ( 0 < sizeOfActualPool )
36541 : {
36542 0 : storageArraySgOmpTeamsDistributeStatement = new SgOmpTeamsDistributeStatementStorageClass[sizeOfActualPool] ;
36543 0 : inFile.read ( (char*) (storageArraySgOmpTeamsDistributeStatement) , sizeof ( SgOmpTeamsDistributeStatementStorageClass ) * sizeOfActualPool) ;
36544 0 : SgOmpTeamsDistributeStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36545 : SgOmpTeamsDistributeStatementStorageClass* storageArray = storageArraySgOmpTeamsDistributeStatement;
36546 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36547 : {
36548 0 : SgOmpTeamsDistributeStatement* tmp = new SgOmpTeamsDistributeStatement ( *storageArray ) ;
36549 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36550 0 : storageArray++ ;
36551 : }
36552 : }
36553 0 : delete [] storageArraySgOmpTeamsDistributeStatement;
36554 2 : SgOmpTeamsDistributeStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36555 :
36556 :
36557 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsDistributeSimdStatement );
36558 2 : SgOmpTeamsDistributeSimdStatementStorageClass* storageArraySgOmpTeamsDistributeSimdStatement = NULL;
36559 2 : if ( 0 < sizeOfActualPool )
36560 : {
36561 0 : storageArraySgOmpTeamsDistributeSimdStatement = new SgOmpTeamsDistributeSimdStatementStorageClass[sizeOfActualPool] ;
36562 0 : inFile.read ( (char*) (storageArraySgOmpTeamsDistributeSimdStatement) , sizeof ( SgOmpTeamsDistributeSimdStatementStorageClass ) * sizeOfActualPool) ;
36563 0 : SgOmpTeamsDistributeSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36564 : SgOmpTeamsDistributeSimdStatementStorageClass* storageArray = storageArraySgOmpTeamsDistributeSimdStatement;
36565 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36566 : {
36567 0 : SgOmpTeamsDistributeSimdStatement* tmp = new SgOmpTeamsDistributeSimdStatement ( *storageArray ) ;
36568 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36569 0 : storageArray++ ;
36570 : }
36571 : }
36572 0 : delete [] storageArraySgOmpTeamsDistributeSimdStatement;
36573 2 : SgOmpTeamsDistributeSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36574 :
36575 :
36576 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsDistributeParallelForStatement );
36577 2 : SgOmpTeamsDistributeParallelForStatementStorageClass* storageArraySgOmpTeamsDistributeParallelForStatement = NULL;
36578 2 : if ( 0 < sizeOfActualPool )
36579 : {
36580 0 : storageArraySgOmpTeamsDistributeParallelForStatement = new SgOmpTeamsDistributeParallelForStatementStorageClass[sizeOfActualPool] ;
36581 0 : inFile.read ( (char*) (storageArraySgOmpTeamsDistributeParallelForStatement) , sizeof ( SgOmpTeamsDistributeParallelForStatementStorageClass ) * sizeOfActualPool) ;
36582 0 : SgOmpTeamsDistributeParallelForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36583 : SgOmpTeamsDistributeParallelForStatementStorageClass* storageArray = storageArraySgOmpTeamsDistributeParallelForStatement;
36584 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36585 : {
36586 0 : SgOmpTeamsDistributeParallelForStatement* tmp = new SgOmpTeamsDistributeParallelForStatement ( *storageArray ) ;
36587 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36588 0 : storageArray++ ;
36589 : }
36590 : }
36591 0 : delete [] storageArraySgOmpTeamsDistributeParallelForStatement;
36592 2 : SgOmpTeamsDistributeParallelForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36593 :
36594 :
36595 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsDistributeParallelForSimdStatement );
36596 2 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass* storageArraySgOmpTeamsDistributeParallelForSimdStatement = NULL;
36597 2 : if ( 0 < sizeOfActualPool )
36598 : {
36599 0 : storageArraySgOmpTeamsDistributeParallelForSimdStatement = new SgOmpTeamsDistributeParallelForSimdStatementStorageClass[sizeOfActualPool] ;
36600 0 : inFile.read ( (char*) (storageArraySgOmpTeamsDistributeParallelForSimdStatement) , sizeof ( SgOmpTeamsDistributeParallelForSimdStatementStorageClass ) * sizeOfActualPool) ;
36601 0 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36602 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass* storageArray = storageArraySgOmpTeamsDistributeParallelForSimdStatement;
36603 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36604 : {
36605 0 : SgOmpTeamsDistributeParallelForSimdStatement* tmp = new SgOmpTeamsDistributeParallelForSimdStatement ( *storageArray ) ;
36606 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36607 0 : storageArray++ ;
36608 : }
36609 : }
36610 0 : delete [] storageArraySgOmpTeamsDistributeParallelForSimdStatement;
36611 2 : SgOmpTeamsDistributeParallelForSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36612 :
36613 :
36614 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTeamsLoopStatement );
36615 2 : SgOmpTeamsLoopStatementStorageClass* storageArraySgOmpTeamsLoopStatement = NULL;
36616 2 : if ( 0 < sizeOfActualPool )
36617 : {
36618 0 : storageArraySgOmpTeamsLoopStatement = new SgOmpTeamsLoopStatementStorageClass[sizeOfActualPool] ;
36619 0 : inFile.read ( (char*) (storageArraySgOmpTeamsLoopStatement) , sizeof ( SgOmpTeamsLoopStatementStorageClass ) * sizeOfActualPool) ;
36620 0 : SgOmpTeamsLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36621 : SgOmpTeamsLoopStatementStorageClass* storageArray = storageArraySgOmpTeamsLoopStatement;
36622 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36623 : {
36624 0 : SgOmpTeamsLoopStatement* tmp = new SgOmpTeamsLoopStatement ( *storageArray ) ;
36625 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36626 0 : storageArray++ ;
36627 : }
36628 : }
36629 0 : delete [] storageArraySgOmpTeamsLoopStatement;
36630 2 : SgOmpTeamsLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36631 :
36632 :
36633 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpParallelLoopStatement );
36634 2 : SgOmpParallelLoopStatementStorageClass* storageArraySgOmpParallelLoopStatement = NULL;
36635 2 : if ( 0 < sizeOfActualPool )
36636 : {
36637 0 : storageArraySgOmpParallelLoopStatement = new SgOmpParallelLoopStatementStorageClass[sizeOfActualPool] ;
36638 0 : inFile.read ( (char*) (storageArraySgOmpParallelLoopStatement) , sizeof ( SgOmpParallelLoopStatementStorageClass ) * sizeOfActualPool) ;
36639 0 : SgOmpParallelLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36640 : SgOmpParallelLoopStatementStorageClass* storageArray = storageArraySgOmpParallelLoopStatement;
36641 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36642 : {
36643 0 : SgOmpParallelLoopStatement* tmp = new SgOmpParallelLoopStatement ( *storageArray ) ;
36644 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36645 0 : storageArray++ ;
36646 : }
36647 : }
36648 0 : delete [] storageArraySgOmpParallelLoopStatement;
36649 2 : SgOmpParallelLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36650 :
36651 :
36652 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpParallelMasterStatement );
36653 2 : SgOmpParallelMasterStatementStorageClass* storageArraySgOmpParallelMasterStatement = NULL;
36654 2 : if ( 0 < sizeOfActualPool )
36655 : {
36656 0 : storageArraySgOmpParallelMasterStatement = new SgOmpParallelMasterStatementStorageClass[sizeOfActualPool] ;
36657 0 : inFile.read ( (char*) (storageArraySgOmpParallelMasterStatement) , sizeof ( SgOmpParallelMasterStatementStorageClass ) * sizeOfActualPool) ;
36658 0 : SgOmpParallelMasterStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36659 : SgOmpParallelMasterStatementStorageClass* storageArray = storageArraySgOmpParallelMasterStatement;
36660 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36661 : {
36662 0 : SgOmpParallelMasterStatement* tmp = new SgOmpParallelMasterStatement ( *storageArray ) ;
36663 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36664 0 : storageArray++ ;
36665 : }
36666 : }
36667 0 : delete [] storageArraySgOmpParallelMasterStatement;
36668 2 : SgOmpParallelMasterStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36669 :
36670 :
36671 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMasterTaskloopStatement );
36672 2 : SgOmpMasterTaskloopStatementStorageClass* storageArraySgOmpMasterTaskloopStatement = NULL;
36673 2 : if ( 0 < sizeOfActualPool )
36674 : {
36675 0 : storageArraySgOmpMasterTaskloopStatement = new SgOmpMasterTaskloopStatementStorageClass[sizeOfActualPool] ;
36676 0 : inFile.read ( (char*) (storageArraySgOmpMasterTaskloopStatement) , sizeof ( SgOmpMasterTaskloopStatementStorageClass ) * sizeOfActualPool) ;
36677 0 : SgOmpMasterTaskloopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36678 : SgOmpMasterTaskloopStatementStorageClass* storageArray = storageArraySgOmpMasterTaskloopStatement;
36679 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36680 : {
36681 0 : SgOmpMasterTaskloopStatement* tmp = new SgOmpMasterTaskloopStatement ( *storageArray ) ;
36682 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36683 0 : storageArray++ ;
36684 : }
36685 : }
36686 0 : delete [] storageArraySgOmpMasterTaskloopStatement;
36687 2 : SgOmpMasterTaskloopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36688 :
36689 :
36690 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUnrollStatement );
36691 2 : SgOmpUnrollStatementStorageClass* storageArraySgOmpUnrollStatement = NULL;
36692 2 : if ( 0 < sizeOfActualPool )
36693 : {
36694 0 : storageArraySgOmpUnrollStatement = new SgOmpUnrollStatementStorageClass[sizeOfActualPool] ;
36695 0 : inFile.read ( (char*) (storageArraySgOmpUnrollStatement) , sizeof ( SgOmpUnrollStatementStorageClass ) * sizeOfActualPool) ;
36696 0 : SgOmpUnrollStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36697 : SgOmpUnrollStatementStorageClass* storageArray = storageArraySgOmpUnrollStatement;
36698 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36699 : {
36700 0 : SgOmpUnrollStatement* tmp = new SgOmpUnrollStatement ( *storageArray ) ;
36701 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36702 0 : storageArray++ ;
36703 : }
36704 : }
36705 0 : delete [] storageArraySgOmpUnrollStatement;
36706 2 : SgOmpUnrollStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36707 :
36708 :
36709 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTileStatement );
36710 2 : SgOmpTileStatementStorageClass* storageArraySgOmpTileStatement = NULL;
36711 2 : if ( 0 < sizeOfActualPool )
36712 : {
36713 0 : storageArraySgOmpTileStatement = new SgOmpTileStatementStorageClass[sizeOfActualPool] ;
36714 0 : inFile.read ( (char*) (storageArraySgOmpTileStatement) , sizeof ( SgOmpTileStatementStorageClass ) * sizeOfActualPool) ;
36715 0 : SgOmpTileStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36716 : SgOmpTileStatementStorageClass* storageArray = storageArraySgOmpTileStatement;
36717 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36718 : {
36719 0 : SgOmpTileStatement* tmp = new SgOmpTileStatement ( *storageArray ) ;
36720 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36721 0 : storageArray++ ;
36722 : }
36723 : }
36724 0 : delete [] storageArraySgOmpTileStatement;
36725 2 : SgOmpTileStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36726 :
36727 :
36728 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirSimdStatement );
36729 2 : SgUpirSimdStatementStorageClass* storageArraySgUpirSimdStatement = NULL;
36730 2 : if ( 0 < sizeOfActualPool )
36731 : {
36732 0 : storageArraySgUpirSimdStatement = new SgUpirSimdStatementStorageClass[sizeOfActualPool] ;
36733 0 : inFile.read ( (char*) (storageArraySgUpirSimdStatement) , sizeof ( SgUpirSimdStatementStorageClass ) * sizeOfActualPool) ;
36734 0 : SgUpirSimdStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36735 : SgUpirSimdStatementStorageClass* storageArray = storageArraySgUpirSimdStatement;
36736 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36737 : {
36738 0 : SgUpirSimdStatement* tmp = new SgUpirSimdStatement ( *storageArray ) ;
36739 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36740 0 : storageArray++ ;
36741 : }
36742 : }
36743 0 : delete [] storageArraySgUpirSimdStatement;
36744 2 : SgUpirSimdStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36745 :
36746 :
36747 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirBaseStatement );
36748 2 : SgUpirBaseStatementStorageClass* storageArraySgUpirBaseStatement = NULL;
36749 2 : if ( 0 < sizeOfActualPool )
36750 : {
36751 0 : storageArraySgUpirBaseStatement = new SgUpirBaseStatementStorageClass[sizeOfActualPool] ;
36752 0 : inFile.read ( (char*) (storageArraySgUpirBaseStatement) , sizeof ( SgUpirBaseStatementStorageClass ) * sizeOfActualPool) ;
36753 0 : SgUpirBaseStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36754 : SgUpirBaseStatementStorageClass* storageArray = storageArraySgUpirBaseStatement;
36755 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36756 : {
36757 0 : SgUpirBaseStatement* tmp = new SgUpirBaseStatement ( *storageArray ) ;
36758 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36759 0 : storageArray++ ;
36760 : }
36761 : }
36762 0 : delete [] storageArraySgUpirBaseStatement;
36763 2 : SgUpirBaseStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36764 :
36765 :
36766 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirLoopStatement );
36767 2 : SgUpirLoopStatementStorageClass* storageArraySgUpirLoopStatement = NULL;
36768 2 : if ( 0 < sizeOfActualPool )
36769 : {
36770 0 : storageArraySgUpirLoopStatement = new SgUpirLoopStatementStorageClass[sizeOfActualPool] ;
36771 0 : inFile.read ( (char*) (storageArraySgUpirLoopStatement) , sizeof ( SgUpirLoopStatementStorageClass ) * sizeOfActualPool) ;
36772 0 : SgUpirLoopStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36773 : SgUpirLoopStatementStorageClass* storageArray = storageArraySgUpirLoopStatement;
36774 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36775 : {
36776 0 : SgUpirLoopStatement* tmp = new SgUpirLoopStatement ( *storageArray ) ;
36777 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36778 0 : storageArray++ ;
36779 : }
36780 : }
36781 0 : delete [] storageArraySgUpirLoopStatement;
36782 2 : SgUpirLoopStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36783 :
36784 :
36785 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirLoopParallelStatement );
36786 2 : SgUpirLoopParallelStatementStorageClass* storageArraySgUpirLoopParallelStatement = NULL;
36787 2 : if ( 0 < sizeOfActualPool )
36788 : {
36789 0 : storageArraySgUpirLoopParallelStatement = new SgUpirLoopParallelStatementStorageClass[sizeOfActualPool] ;
36790 0 : inFile.read ( (char*) (storageArraySgUpirLoopParallelStatement) , sizeof ( SgUpirLoopParallelStatementStorageClass ) * sizeOfActualPool) ;
36791 0 : SgUpirLoopParallelStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36792 : SgUpirLoopParallelStatementStorageClass* storageArray = storageArraySgUpirLoopParallelStatement;
36793 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36794 : {
36795 0 : SgUpirLoopParallelStatement* tmp = new SgUpirLoopParallelStatement ( *storageArray ) ;
36796 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36797 0 : storageArray++ ;
36798 : }
36799 : }
36800 0 : delete [] storageArraySgUpirLoopParallelStatement;
36801 2 : SgUpirLoopParallelStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36802 :
36803 :
36804 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirSyncStatement );
36805 2 : SgUpirSyncStatementStorageClass* storageArraySgUpirSyncStatement = NULL;
36806 2 : if ( 0 < sizeOfActualPool )
36807 : {
36808 0 : storageArraySgUpirSyncStatement = new SgUpirSyncStatementStorageClass[sizeOfActualPool] ;
36809 0 : inFile.read ( (char*) (storageArraySgUpirSyncStatement) , sizeof ( SgUpirSyncStatementStorageClass ) * sizeOfActualPool) ;
36810 0 : SgUpirSyncStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
36811 : SgUpirSyncStatementStorageClass* storageArray = storageArraySgUpirSyncStatement;
36812 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36813 : {
36814 0 : SgUpirSyncStatement* tmp = new SgUpirSyncStatement ( *storageArray ) ;
36815 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36816 0 : storageArray++ ;
36817 : }
36818 : }
36819 0 : delete [] storageArraySgUpirSyncStatement;
36820 2 : SgUpirSyncStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
36821 :
36822 :
36823 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpClause );
36824 2 : SgOmpClauseStorageClass* storageArraySgOmpClause = NULL;
36825 2 : if ( 0 < sizeOfActualPool )
36826 : {
36827 0 : storageArraySgOmpClause = new SgOmpClauseStorageClass[sizeOfActualPool] ;
36828 0 : inFile.read ( (char*) (storageArraySgOmpClause) , sizeof ( SgOmpClauseStorageClass ) * sizeOfActualPool) ;
36829 0 : SgOmpClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36830 : SgOmpClauseStorageClass* storageArray = storageArraySgOmpClause;
36831 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36832 : {
36833 0 : SgOmpClause* tmp = new SgOmpClause ( *storageArray ) ;
36834 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36835 0 : storageArray++ ;
36836 : }
36837 : }
36838 0 : delete [] storageArraySgOmpClause;
36839 2 : SgOmpClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36840 :
36841 :
36842 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAllocateClause );
36843 2 : SgOmpAllocateClauseStorageClass* storageArraySgOmpAllocateClause = NULL;
36844 2 : if ( 0 < sizeOfActualPool )
36845 : {
36846 0 : storageArraySgOmpAllocateClause = new SgOmpAllocateClauseStorageClass[sizeOfActualPool] ;
36847 0 : inFile.read ( (char*) (storageArraySgOmpAllocateClause) , sizeof ( SgOmpAllocateClauseStorageClass ) * sizeOfActualPool) ;
36848 0 : SgOmpAllocateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36849 : SgOmpAllocateClauseStorageClass* storageArray = storageArraySgOmpAllocateClause;
36850 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36851 : {
36852 0 : SgOmpAllocateClause* tmp = new SgOmpAllocateClause ( *storageArray ) ;
36853 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36854 0 : storageArray++ ;
36855 : }
36856 : }
36857 0 : delete [] storageArraySgOmpAllocateClause;
36858 2 : SgOmpAllocateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36859 :
36860 :
36861 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAllocatorClause );
36862 2 : SgOmpAllocatorClauseStorageClass* storageArraySgOmpAllocatorClause = NULL;
36863 2 : if ( 0 < sizeOfActualPool )
36864 : {
36865 0 : storageArraySgOmpAllocatorClause = new SgOmpAllocatorClauseStorageClass[sizeOfActualPool] ;
36866 0 : inFile.read ( (char*) (storageArraySgOmpAllocatorClause) , sizeof ( SgOmpAllocatorClauseStorageClass ) * sizeOfActualPool) ;
36867 0 : SgOmpAllocatorClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36868 : SgOmpAllocatorClauseStorageClass* storageArray = storageArraySgOmpAllocatorClause;
36869 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36870 : {
36871 0 : SgOmpAllocatorClause* tmp = new SgOmpAllocatorClause ( *storageArray ) ;
36872 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36873 0 : storageArray++ ;
36874 : }
36875 : }
36876 0 : delete [] storageArraySgOmpAllocatorClause;
36877 2 : SgOmpAllocatorClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36878 :
36879 :
36880 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUsesAllocatorsClause );
36881 2 : SgOmpUsesAllocatorsClauseStorageClass* storageArraySgOmpUsesAllocatorsClause = NULL;
36882 2 : if ( 0 < sizeOfActualPool )
36883 : {
36884 0 : storageArraySgOmpUsesAllocatorsClause = new SgOmpUsesAllocatorsClauseStorageClass[sizeOfActualPool] ;
36885 0 : inFile.read ( (char*) (storageArraySgOmpUsesAllocatorsClause) , sizeof ( SgOmpUsesAllocatorsClauseStorageClass ) * sizeOfActualPool) ;
36886 0 : SgOmpUsesAllocatorsClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36887 : SgOmpUsesAllocatorsClauseStorageClass* storageArray = storageArraySgOmpUsesAllocatorsClause;
36888 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36889 : {
36890 0 : SgOmpUsesAllocatorsClause* tmp = new SgOmpUsesAllocatorsClause ( *storageArray ) ;
36891 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36892 0 : storageArray++ ;
36893 : }
36894 : }
36895 0 : delete [] storageArraySgOmpUsesAllocatorsClause;
36896 2 : SgOmpUsesAllocatorsClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36897 :
36898 :
36899 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUsesAllocatorsDefination );
36900 2 : SgOmpUsesAllocatorsDefinationStorageClass* storageArraySgOmpUsesAllocatorsDefination = NULL;
36901 2 : if ( 0 < sizeOfActualPool )
36902 : {
36903 0 : storageArraySgOmpUsesAllocatorsDefination = new SgOmpUsesAllocatorsDefinationStorageClass[sizeOfActualPool] ;
36904 0 : inFile.read ( (char*) (storageArraySgOmpUsesAllocatorsDefination) , sizeof ( SgOmpUsesAllocatorsDefinationStorageClass ) * sizeOfActualPool) ;
36905 0 : SgOmpUsesAllocatorsDefinationStorageClass :: readEasyStorageDataFromFile(inFile) ;
36906 : SgOmpUsesAllocatorsDefinationStorageClass* storageArray = storageArraySgOmpUsesAllocatorsDefination;
36907 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36908 : {
36909 0 : SgOmpUsesAllocatorsDefination* tmp = new SgOmpUsesAllocatorsDefination ( *storageArray ) ;
36910 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36911 0 : storageArray++ ;
36912 : }
36913 : }
36914 0 : delete [] storageArraySgOmpUsesAllocatorsDefination;
36915 2 : SgOmpUsesAllocatorsDefinationStorageClass :: deleteStaticDataOfEasyStorageClasses();
36916 :
36917 :
36918 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpToClause );
36919 2 : SgOmpToClauseStorageClass* storageArraySgOmpToClause = NULL;
36920 2 : if ( 0 < sizeOfActualPool )
36921 : {
36922 0 : storageArraySgOmpToClause = new SgOmpToClauseStorageClass[sizeOfActualPool] ;
36923 0 : inFile.read ( (char*) (storageArraySgOmpToClause) , sizeof ( SgOmpToClauseStorageClass ) * sizeOfActualPool) ;
36924 0 : SgOmpToClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36925 : SgOmpToClauseStorageClass* storageArray = storageArraySgOmpToClause;
36926 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36927 : {
36928 0 : SgOmpToClause* tmp = new SgOmpToClause ( *storageArray ) ;
36929 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36930 0 : storageArray++ ;
36931 : }
36932 : }
36933 0 : delete [] storageArraySgOmpToClause;
36934 2 : SgOmpToClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36935 :
36936 :
36937 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpFromClause );
36938 2 : SgOmpFromClauseStorageClass* storageArraySgOmpFromClause = NULL;
36939 2 : if ( 0 < sizeOfActualPool )
36940 : {
36941 0 : storageArraySgOmpFromClause = new SgOmpFromClauseStorageClass[sizeOfActualPool] ;
36942 0 : inFile.read ( (char*) (storageArraySgOmpFromClause) , sizeof ( SgOmpFromClauseStorageClass ) * sizeOfActualPool) ;
36943 0 : SgOmpFromClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36944 : SgOmpFromClauseStorageClass* storageArray = storageArraySgOmpFromClause;
36945 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36946 : {
36947 0 : SgOmpFromClause* tmp = new SgOmpFromClause ( *storageArray ) ;
36948 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36949 0 : storageArray++ ;
36950 : }
36951 : }
36952 0 : delete [] storageArraySgOmpFromClause;
36953 2 : SgOmpFromClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36954 :
36955 :
36956 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpThreadsClause );
36957 2 : SgOmpThreadsClauseStorageClass* storageArraySgOmpThreadsClause = NULL;
36958 2 : if ( 0 < sizeOfActualPool )
36959 : {
36960 0 : storageArraySgOmpThreadsClause = new SgOmpThreadsClauseStorageClass[sizeOfActualPool] ;
36961 0 : inFile.read ( (char*) (storageArraySgOmpThreadsClause) , sizeof ( SgOmpThreadsClauseStorageClass ) * sizeOfActualPool) ;
36962 0 : SgOmpThreadsClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36963 : SgOmpThreadsClauseStorageClass* storageArray = storageArraySgOmpThreadsClause;
36964 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36965 : {
36966 0 : SgOmpThreadsClause* tmp = new SgOmpThreadsClause ( *storageArray ) ;
36967 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36968 0 : storageArray++ ;
36969 : }
36970 : }
36971 0 : delete [] storageArraySgOmpThreadsClause;
36972 2 : SgOmpThreadsClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36973 :
36974 :
36975 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSimdClause );
36976 2 : SgOmpSimdClauseStorageClass* storageArraySgOmpSimdClause = NULL;
36977 2 : if ( 0 < sizeOfActualPool )
36978 : {
36979 0 : storageArraySgOmpSimdClause = new SgOmpSimdClauseStorageClass[sizeOfActualPool] ;
36980 0 : inFile.read ( (char*) (storageArraySgOmpSimdClause) , sizeof ( SgOmpSimdClauseStorageClass ) * sizeOfActualPool) ;
36981 0 : SgOmpSimdClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
36982 : SgOmpSimdClauseStorageClass* storageArray = storageArraySgOmpSimdClause;
36983 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
36984 : {
36985 0 : SgOmpSimdClause* tmp = new SgOmpSimdClause ( *storageArray ) ;
36986 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
36987 0 : storageArray++ ;
36988 : }
36989 : }
36990 0 : delete [] storageArraySgOmpSimdClause;
36991 2 : SgOmpSimdClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
36992 :
36993 :
36994 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpBeginClause );
36995 2 : SgOmpBeginClauseStorageClass* storageArraySgOmpBeginClause = NULL;
36996 2 : if ( 0 < sizeOfActualPool )
36997 : {
36998 0 : storageArraySgOmpBeginClause = new SgOmpBeginClauseStorageClass[sizeOfActualPool] ;
36999 0 : inFile.read ( (char*) (storageArraySgOmpBeginClause) , sizeof ( SgOmpBeginClauseStorageClass ) * sizeOfActualPool) ;
37000 0 : SgOmpBeginClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37001 : SgOmpBeginClauseStorageClass* storageArray = storageArraySgOmpBeginClause;
37002 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37003 : {
37004 0 : SgOmpBeginClause* tmp = new SgOmpBeginClause ( *storageArray ) ;
37005 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37006 0 : storageArray++ ;
37007 : }
37008 : }
37009 0 : delete [] storageArraySgOmpBeginClause;
37010 2 : SgOmpBeginClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37011 :
37012 :
37013 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCollapseClause );
37014 2 : SgOmpCollapseClauseStorageClass* storageArraySgOmpCollapseClause = NULL;
37015 2 : if ( 0 < sizeOfActualPool )
37016 : {
37017 0 : storageArraySgOmpCollapseClause = new SgOmpCollapseClauseStorageClass[sizeOfActualPool] ;
37018 0 : inFile.read ( (char*) (storageArraySgOmpCollapseClause) , sizeof ( SgOmpCollapseClauseStorageClass ) * sizeOfActualPool) ;
37019 0 : SgOmpCollapseClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37020 : SgOmpCollapseClauseStorageClass* storageArray = storageArraySgOmpCollapseClause;
37021 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37022 : {
37023 0 : SgOmpCollapseClause* tmp = new SgOmpCollapseClause ( *storageArray ) ;
37024 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37025 0 : storageArray++ ;
37026 : }
37027 : }
37028 0 : delete [] storageArraySgOmpCollapseClause;
37029 2 : SgOmpCollapseClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37030 :
37031 :
37032 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCopyinClause );
37033 2 : SgOmpCopyinClauseStorageClass* storageArraySgOmpCopyinClause = NULL;
37034 2 : if ( 0 < sizeOfActualPool )
37035 : {
37036 0 : storageArraySgOmpCopyinClause = new SgOmpCopyinClauseStorageClass[sizeOfActualPool] ;
37037 0 : inFile.read ( (char*) (storageArraySgOmpCopyinClause) , sizeof ( SgOmpCopyinClauseStorageClass ) * sizeOfActualPool) ;
37038 0 : SgOmpCopyinClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37039 : SgOmpCopyinClauseStorageClass* storageArray = storageArraySgOmpCopyinClause;
37040 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37041 : {
37042 0 : SgOmpCopyinClause* tmp = new SgOmpCopyinClause ( *storageArray ) ;
37043 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37044 0 : storageArray++ ;
37045 : }
37046 : }
37047 0 : delete [] storageArraySgOmpCopyinClause;
37048 2 : SgOmpCopyinClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37049 :
37050 :
37051 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCopyprivateClause );
37052 2 : SgOmpCopyprivateClauseStorageClass* storageArraySgOmpCopyprivateClause = NULL;
37053 2 : if ( 0 < sizeOfActualPool )
37054 : {
37055 0 : storageArraySgOmpCopyprivateClause = new SgOmpCopyprivateClauseStorageClass[sizeOfActualPool] ;
37056 0 : inFile.read ( (char*) (storageArraySgOmpCopyprivateClause) , sizeof ( SgOmpCopyprivateClauseStorageClass ) * sizeOfActualPool) ;
37057 0 : SgOmpCopyprivateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37058 : SgOmpCopyprivateClauseStorageClass* storageArray = storageArraySgOmpCopyprivateClause;
37059 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37060 : {
37061 0 : SgOmpCopyprivateClause* tmp = new SgOmpCopyprivateClause ( *storageArray ) ;
37062 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37063 0 : storageArray++ ;
37064 : }
37065 : }
37066 0 : delete [] storageArraySgOmpCopyprivateClause;
37067 2 : SgOmpCopyprivateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37068 :
37069 :
37070 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDefaultClause );
37071 2 : SgOmpDefaultClauseStorageClass* storageArraySgOmpDefaultClause = NULL;
37072 2 : if ( 0 < sizeOfActualPool )
37073 : {
37074 0 : storageArraySgOmpDefaultClause = new SgOmpDefaultClauseStorageClass[sizeOfActualPool] ;
37075 0 : inFile.read ( (char*) (storageArraySgOmpDefaultClause) , sizeof ( SgOmpDefaultClauseStorageClass ) * sizeOfActualPool) ;
37076 0 : SgOmpDefaultClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37077 : SgOmpDefaultClauseStorageClass* storageArray = storageArraySgOmpDefaultClause;
37078 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37079 : {
37080 0 : SgOmpDefaultClause* tmp = new SgOmpDefaultClause ( *storageArray ) ;
37081 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37082 0 : storageArray++ ;
37083 : }
37084 : }
37085 0 : delete [] storageArraySgOmpDefaultClause;
37086 2 : SgOmpDefaultClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37087 :
37088 :
37089 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpEndClause );
37090 2 : SgOmpEndClauseStorageClass* storageArraySgOmpEndClause = NULL;
37091 2 : if ( 0 < sizeOfActualPool )
37092 : {
37093 0 : storageArraySgOmpEndClause = new SgOmpEndClauseStorageClass[sizeOfActualPool] ;
37094 0 : inFile.read ( (char*) (storageArraySgOmpEndClause) , sizeof ( SgOmpEndClauseStorageClass ) * sizeOfActualPool) ;
37095 0 : SgOmpEndClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37096 : SgOmpEndClauseStorageClass* storageArray = storageArraySgOmpEndClause;
37097 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37098 : {
37099 0 : SgOmpEndClause* tmp = new SgOmpEndClause ( *storageArray ) ;
37100 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37101 0 : storageArray++ ;
37102 : }
37103 : }
37104 0 : delete [] storageArraySgOmpEndClause;
37105 2 : SgOmpEndClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37106 :
37107 :
37108 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpExpressionClause );
37109 2 : SgOmpExpressionClauseStorageClass* storageArraySgOmpExpressionClause = NULL;
37110 2 : if ( 0 < sizeOfActualPool )
37111 : {
37112 0 : storageArraySgOmpExpressionClause = new SgOmpExpressionClauseStorageClass[sizeOfActualPool] ;
37113 0 : inFile.read ( (char*) (storageArraySgOmpExpressionClause) , sizeof ( SgOmpExpressionClauseStorageClass ) * sizeOfActualPool) ;
37114 0 : SgOmpExpressionClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37115 : SgOmpExpressionClauseStorageClass* storageArray = storageArraySgOmpExpressionClause;
37116 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37117 : {
37118 0 : SgOmpExpressionClause* tmp = new SgOmpExpressionClause ( *storageArray ) ;
37119 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37120 0 : storageArray++ ;
37121 : }
37122 : }
37123 0 : delete [] storageArraySgOmpExpressionClause;
37124 2 : SgOmpExpressionClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37125 :
37126 :
37127 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpFirstprivateClause );
37128 2 : SgOmpFirstprivateClauseStorageClass* storageArraySgOmpFirstprivateClause = NULL;
37129 2 : if ( 0 < sizeOfActualPool )
37130 : {
37131 0 : storageArraySgOmpFirstprivateClause = new SgOmpFirstprivateClauseStorageClass[sizeOfActualPool] ;
37132 0 : inFile.read ( (char*) (storageArraySgOmpFirstprivateClause) , sizeof ( SgOmpFirstprivateClauseStorageClass ) * sizeOfActualPool) ;
37133 0 : SgOmpFirstprivateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37134 : SgOmpFirstprivateClauseStorageClass* storageArray = storageArraySgOmpFirstprivateClause;
37135 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37136 : {
37137 0 : SgOmpFirstprivateClause* tmp = new SgOmpFirstprivateClause ( *storageArray ) ;
37138 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37139 0 : storageArray++ ;
37140 : }
37141 : }
37142 0 : delete [] storageArraySgOmpFirstprivateClause;
37143 2 : SgOmpFirstprivateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37144 :
37145 :
37146 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpIfClause );
37147 2 : SgOmpIfClauseStorageClass* storageArraySgOmpIfClause = NULL;
37148 2 : if ( 0 < sizeOfActualPool )
37149 : {
37150 0 : storageArraySgOmpIfClause = new SgOmpIfClauseStorageClass[sizeOfActualPool] ;
37151 0 : inFile.read ( (char*) (storageArraySgOmpIfClause) , sizeof ( SgOmpIfClauseStorageClass ) * sizeOfActualPool) ;
37152 0 : SgOmpIfClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37153 : SgOmpIfClauseStorageClass* storageArray = storageArraySgOmpIfClause;
37154 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37155 : {
37156 0 : SgOmpIfClause* tmp = new SgOmpIfClause ( *storageArray ) ;
37157 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37158 0 : storageArray++ ;
37159 : }
37160 : }
37161 0 : delete [] storageArraySgOmpIfClause;
37162 2 : SgOmpIfClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37163 :
37164 :
37165 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpFinalClause );
37166 2 : SgOmpFinalClauseStorageClass* storageArraySgOmpFinalClause = NULL;
37167 2 : if ( 0 < sizeOfActualPool )
37168 : {
37169 0 : storageArraySgOmpFinalClause = new SgOmpFinalClauseStorageClass[sizeOfActualPool] ;
37170 0 : inFile.read ( (char*) (storageArraySgOmpFinalClause) , sizeof ( SgOmpFinalClauseStorageClass ) * sizeOfActualPool) ;
37171 0 : SgOmpFinalClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37172 : SgOmpFinalClauseStorageClass* storageArray = storageArraySgOmpFinalClause;
37173 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37174 : {
37175 0 : SgOmpFinalClause* tmp = new SgOmpFinalClause ( *storageArray ) ;
37176 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37177 0 : storageArray++ ;
37178 : }
37179 : }
37180 0 : delete [] storageArraySgOmpFinalClause;
37181 2 : SgOmpFinalClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37182 :
37183 :
37184 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpPriorityClause );
37185 2 : SgOmpPriorityClauseStorageClass* storageArraySgOmpPriorityClause = NULL;
37186 2 : if ( 0 < sizeOfActualPool )
37187 : {
37188 0 : storageArraySgOmpPriorityClause = new SgOmpPriorityClauseStorageClass[sizeOfActualPool] ;
37189 0 : inFile.read ( (char*) (storageArraySgOmpPriorityClause) , sizeof ( SgOmpPriorityClauseStorageClass ) * sizeOfActualPool) ;
37190 0 : SgOmpPriorityClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37191 : SgOmpPriorityClauseStorageClass* storageArray = storageArraySgOmpPriorityClause;
37192 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37193 : {
37194 0 : SgOmpPriorityClause* tmp = new SgOmpPriorityClause ( *storageArray ) ;
37195 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37196 0 : storageArray++ ;
37197 : }
37198 : }
37199 0 : delete [] storageArraySgOmpPriorityClause;
37200 2 : SgOmpPriorityClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37201 :
37202 :
37203 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDeviceClause );
37204 2 : SgOmpDeviceClauseStorageClass* storageArraySgOmpDeviceClause = NULL;
37205 2 : if ( 0 < sizeOfActualPool )
37206 : {
37207 0 : storageArraySgOmpDeviceClause = new SgOmpDeviceClauseStorageClass[sizeOfActualPool] ;
37208 0 : inFile.read ( (char*) (storageArraySgOmpDeviceClause) , sizeof ( SgOmpDeviceClauseStorageClass ) * sizeOfActualPool) ;
37209 0 : SgOmpDeviceClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37210 : SgOmpDeviceClauseStorageClass* storageArray = storageArraySgOmpDeviceClause;
37211 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37212 : {
37213 0 : SgOmpDeviceClause* tmp = new SgOmpDeviceClause ( *storageArray ) ;
37214 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37215 0 : storageArray++ ;
37216 : }
37217 : }
37218 0 : delete [] storageArraySgOmpDeviceClause;
37219 2 : SgOmpDeviceClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37220 :
37221 :
37222 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpLastprivateClause );
37223 2 : SgOmpLastprivateClauseStorageClass* storageArraySgOmpLastprivateClause = NULL;
37224 2 : if ( 0 < sizeOfActualPool )
37225 : {
37226 0 : storageArraySgOmpLastprivateClause = new SgOmpLastprivateClauseStorageClass[sizeOfActualPool] ;
37227 0 : inFile.read ( (char*) (storageArraySgOmpLastprivateClause) , sizeof ( SgOmpLastprivateClauseStorageClass ) * sizeOfActualPool) ;
37228 0 : SgOmpLastprivateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37229 : SgOmpLastprivateClauseStorageClass* storageArray = storageArraySgOmpLastprivateClause;
37230 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37231 : {
37232 0 : SgOmpLastprivateClause* tmp = new SgOmpLastprivateClause ( *storageArray ) ;
37233 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37234 0 : storageArray++ ;
37235 : }
37236 : }
37237 0 : delete [] storageArraySgOmpLastprivateClause;
37238 2 : SgOmpLastprivateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37239 :
37240 :
37241 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNowaitClause );
37242 2 : SgOmpNowaitClauseStorageClass* storageArraySgOmpNowaitClause = NULL;
37243 2 : if ( 0 < sizeOfActualPool )
37244 : {
37245 0 : storageArraySgOmpNowaitClause = new SgOmpNowaitClauseStorageClass[sizeOfActualPool] ;
37246 0 : inFile.read ( (char*) (storageArraySgOmpNowaitClause) , sizeof ( SgOmpNowaitClauseStorageClass ) * sizeOfActualPool) ;
37247 0 : SgOmpNowaitClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37248 : SgOmpNowaitClauseStorageClass* storageArray = storageArraySgOmpNowaitClause;
37249 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37250 : {
37251 0 : SgOmpNowaitClause* tmp = new SgOmpNowaitClause ( *storageArray ) ;
37252 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37253 0 : storageArray++ ;
37254 : }
37255 : }
37256 0 : delete [] storageArraySgOmpNowaitClause;
37257 2 : SgOmpNowaitClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37258 :
37259 :
37260 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpReadClause );
37261 2 : SgOmpReadClauseStorageClass* storageArraySgOmpReadClause = NULL;
37262 2 : if ( 0 < sizeOfActualPool )
37263 : {
37264 0 : storageArraySgOmpReadClause = new SgOmpReadClauseStorageClass[sizeOfActualPool] ;
37265 0 : inFile.read ( (char*) (storageArraySgOmpReadClause) , sizeof ( SgOmpReadClauseStorageClass ) * sizeOfActualPool) ;
37266 0 : SgOmpReadClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37267 : SgOmpReadClauseStorageClass* storageArray = storageArraySgOmpReadClause;
37268 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37269 : {
37270 0 : SgOmpReadClause* tmp = new SgOmpReadClause ( *storageArray ) ;
37271 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37272 0 : storageArray++ ;
37273 : }
37274 : }
37275 0 : delete [] storageArraySgOmpReadClause;
37276 2 : SgOmpReadClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37277 :
37278 :
37279 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpWriteClause );
37280 2 : SgOmpWriteClauseStorageClass* storageArraySgOmpWriteClause = NULL;
37281 2 : if ( 0 < sizeOfActualPool )
37282 : {
37283 0 : storageArraySgOmpWriteClause = new SgOmpWriteClauseStorageClass[sizeOfActualPool] ;
37284 0 : inFile.read ( (char*) (storageArraySgOmpWriteClause) , sizeof ( SgOmpWriteClauseStorageClass ) * sizeOfActualPool) ;
37285 0 : SgOmpWriteClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37286 : SgOmpWriteClauseStorageClass* storageArray = storageArraySgOmpWriteClause;
37287 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37288 : {
37289 0 : SgOmpWriteClause* tmp = new SgOmpWriteClause ( *storageArray ) ;
37290 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37291 0 : storageArray++ ;
37292 : }
37293 : }
37294 0 : delete [] storageArraySgOmpWriteClause;
37295 2 : SgOmpWriteClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37296 :
37297 :
37298 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUpdateClause );
37299 2 : SgOmpUpdateClauseStorageClass* storageArraySgOmpUpdateClause = NULL;
37300 2 : if ( 0 < sizeOfActualPool )
37301 : {
37302 0 : storageArraySgOmpUpdateClause = new SgOmpUpdateClauseStorageClass[sizeOfActualPool] ;
37303 0 : inFile.read ( (char*) (storageArraySgOmpUpdateClause) , sizeof ( SgOmpUpdateClauseStorageClass ) * sizeOfActualPool) ;
37304 0 : SgOmpUpdateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37305 : SgOmpUpdateClauseStorageClass* storageArray = storageArraySgOmpUpdateClause;
37306 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37307 : {
37308 0 : SgOmpUpdateClause* tmp = new SgOmpUpdateClause ( *storageArray ) ;
37309 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37310 0 : storageArray++ ;
37311 : }
37312 : }
37313 0 : delete [] storageArraySgOmpUpdateClause;
37314 2 : SgOmpUpdateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37315 :
37316 :
37317 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDepobjUpdateClause );
37318 2 : SgOmpDepobjUpdateClauseStorageClass* storageArraySgOmpDepobjUpdateClause = NULL;
37319 2 : if ( 0 < sizeOfActualPool )
37320 : {
37321 0 : storageArraySgOmpDepobjUpdateClause = new SgOmpDepobjUpdateClauseStorageClass[sizeOfActualPool] ;
37322 0 : inFile.read ( (char*) (storageArraySgOmpDepobjUpdateClause) , sizeof ( SgOmpDepobjUpdateClauseStorageClass ) * sizeOfActualPool) ;
37323 0 : SgOmpDepobjUpdateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37324 : SgOmpDepobjUpdateClauseStorageClass* storageArray = storageArraySgOmpDepobjUpdateClause;
37325 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37326 : {
37327 0 : SgOmpDepobjUpdateClause* tmp = new SgOmpDepobjUpdateClause ( *storageArray ) ;
37328 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37329 0 : storageArray++ ;
37330 : }
37331 : }
37332 0 : delete [] storageArraySgOmpDepobjUpdateClause;
37333 2 : SgOmpDepobjUpdateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37334 :
37335 :
37336 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDestroyClause );
37337 2 : SgOmpDestroyClauseStorageClass* storageArraySgOmpDestroyClause = NULL;
37338 2 : if ( 0 < sizeOfActualPool )
37339 : {
37340 0 : storageArraySgOmpDestroyClause = new SgOmpDestroyClauseStorageClass[sizeOfActualPool] ;
37341 0 : inFile.read ( (char*) (storageArraySgOmpDestroyClause) , sizeof ( SgOmpDestroyClauseStorageClass ) * sizeOfActualPool) ;
37342 0 : SgOmpDestroyClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37343 : SgOmpDestroyClauseStorageClass* storageArray = storageArraySgOmpDestroyClause;
37344 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37345 : {
37346 0 : SgOmpDestroyClause* tmp = new SgOmpDestroyClause ( *storageArray ) ;
37347 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37348 0 : storageArray++ ;
37349 : }
37350 : }
37351 0 : delete [] storageArraySgOmpDestroyClause;
37352 2 : SgOmpDestroyClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37353 :
37354 :
37355 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpCaptureClause );
37356 2 : SgOmpCaptureClauseStorageClass* storageArraySgOmpCaptureClause = NULL;
37357 2 : if ( 0 < sizeOfActualPool )
37358 : {
37359 0 : storageArraySgOmpCaptureClause = new SgOmpCaptureClauseStorageClass[sizeOfActualPool] ;
37360 0 : inFile.read ( (char*) (storageArraySgOmpCaptureClause) , sizeof ( SgOmpCaptureClauseStorageClass ) * sizeOfActualPool) ;
37361 0 : SgOmpCaptureClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37362 : SgOmpCaptureClauseStorageClass* storageArray = storageArraySgOmpCaptureClause;
37363 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37364 : {
37365 0 : SgOmpCaptureClause* tmp = new SgOmpCaptureClause ( *storageArray ) ;
37366 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37367 0 : storageArray++ ;
37368 : }
37369 : }
37370 0 : delete [] storageArraySgOmpCaptureClause;
37371 2 : SgOmpCaptureClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37372 :
37373 :
37374 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSeqCstClause );
37375 2 : SgOmpSeqCstClauseStorageClass* storageArraySgOmpSeqCstClause = NULL;
37376 2 : if ( 0 < sizeOfActualPool )
37377 : {
37378 0 : storageArraySgOmpSeqCstClause = new SgOmpSeqCstClauseStorageClass[sizeOfActualPool] ;
37379 0 : inFile.read ( (char*) (storageArraySgOmpSeqCstClause) , sizeof ( SgOmpSeqCstClauseStorageClass ) * sizeOfActualPool) ;
37380 0 : SgOmpSeqCstClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37381 : SgOmpSeqCstClauseStorageClass* storageArray = storageArraySgOmpSeqCstClause;
37382 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37383 : {
37384 0 : SgOmpSeqCstClause* tmp = new SgOmpSeqCstClause ( *storageArray ) ;
37385 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37386 0 : storageArray++ ;
37387 : }
37388 : }
37389 0 : delete [] storageArraySgOmpSeqCstClause;
37390 2 : SgOmpSeqCstClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37391 :
37392 :
37393 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAcqRelClause );
37394 2 : SgOmpAcqRelClauseStorageClass* storageArraySgOmpAcqRelClause = NULL;
37395 2 : if ( 0 < sizeOfActualPool )
37396 : {
37397 0 : storageArraySgOmpAcqRelClause = new SgOmpAcqRelClauseStorageClass[sizeOfActualPool] ;
37398 0 : inFile.read ( (char*) (storageArraySgOmpAcqRelClause) , sizeof ( SgOmpAcqRelClauseStorageClass ) * sizeOfActualPool) ;
37399 0 : SgOmpAcqRelClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37400 : SgOmpAcqRelClauseStorageClass* storageArray = storageArraySgOmpAcqRelClause;
37401 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37402 : {
37403 0 : SgOmpAcqRelClause* tmp = new SgOmpAcqRelClause ( *storageArray ) ;
37404 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37405 0 : storageArray++ ;
37406 : }
37407 : }
37408 0 : delete [] storageArraySgOmpAcqRelClause;
37409 2 : SgOmpAcqRelClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37410 :
37411 :
37412 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpReleaseClause );
37413 2 : SgOmpReleaseClauseStorageClass* storageArraySgOmpReleaseClause = NULL;
37414 2 : if ( 0 < sizeOfActualPool )
37415 : {
37416 0 : storageArraySgOmpReleaseClause = new SgOmpReleaseClauseStorageClass[sizeOfActualPool] ;
37417 0 : inFile.read ( (char*) (storageArraySgOmpReleaseClause) , sizeof ( SgOmpReleaseClauseStorageClass ) * sizeOfActualPool) ;
37418 0 : SgOmpReleaseClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37419 : SgOmpReleaseClauseStorageClass* storageArray = storageArraySgOmpReleaseClause;
37420 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37421 : {
37422 0 : SgOmpReleaseClause* tmp = new SgOmpReleaseClause ( *storageArray ) ;
37423 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37424 0 : storageArray++ ;
37425 : }
37426 : }
37427 0 : delete [] storageArraySgOmpReleaseClause;
37428 2 : SgOmpReleaseClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37429 :
37430 :
37431 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAcquireClause );
37432 2 : SgOmpAcquireClauseStorageClass* storageArraySgOmpAcquireClause = NULL;
37433 2 : if ( 0 < sizeOfActualPool )
37434 : {
37435 0 : storageArraySgOmpAcquireClause = new SgOmpAcquireClauseStorageClass[sizeOfActualPool] ;
37436 0 : inFile.read ( (char*) (storageArraySgOmpAcquireClause) , sizeof ( SgOmpAcquireClauseStorageClass ) * sizeOfActualPool) ;
37437 0 : SgOmpAcquireClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37438 : SgOmpAcquireClauseStorageClass* storageArray = storageArraySgOmpAcquireClause;
37439 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37440 : {
37441 0 : SgOmpAcquireClause* tmp = new SgOmpAcquireClause ( *storageArray ) ;
37442 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37443 0 : storageArray++ ;
37444 : }
37445 : }
37446 0 : delete [] storageArraySgOmpAcquireClause;
37447 2 : SgOmpAcquireClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37448 :
37449 :
37450 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpReverseOffloadClause );
37451 2 : SgOmpReverseOffloadClauseStorageClass* storageArraySgOmpReverseOffloadClause = NULL;
37452 2 : if ( 0 < sizeOfActualPool )
37453 : {
37454 0 : storageArraySgOmpReverseOffloadClause = new SgOmpReverseOffloadClauseStorageClass[sizeOfActualPool] ;
37455 0 : inFile.read ( (char*) (storageArraySgOmpReverseOffloadClause) , sizeof ( SgOmpReverseOffloadClauseStorageClass ) * sizeOfActualPool) ;
37456 0 : SgOmpReverseOffloadClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37457 : SgOmpReverseOffloadClauseStorageClass* storageArray = storageArraySgOmpReverseOffloadClause;
37458 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37459 : {
37460 0 : SgOmpReverseOffloadClause* tmp = new SgOmpReverseOffloadClause ( *storageArray ) ;
37461 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37462 0 : storageArray++ ;
37463 : }
37464 : }
37465 0 : delete [] storageArraySgOmpReverseOffloadClause;
37466 2 : SgOmpReverseOffloadClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37467 :
37468 :
37469 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUnifiedAddressClause );
37470 2 : SgOmpUnifiedAddressClauseStorageClass* storageArraySgOmpUnifiedAddressClause = NULL;
37471 2 : if ( 0 < sizeOfActualPool )
37472 : {
37473 0 : storageArraySgOmpUnifiedAddressClause = new SgOmpUnifiedAddressClauseStorageClass[sizeOfActualPool] ;
37474 0 : inFile.read ( (char*) (storageArraySgOmpUnifiedAddressClause) , sizeof ( SgOmpUnifiedAddressClauseStorageClass ) * sizeOfActualPool) ;
37475 0 : SgOmpUnifiedAddressClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37476 : SgOmpUnifiedAddressClauseStorageClass* storageArray = storageArraySgOmpUnifiedAddressClause;
37477 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37478 : {
37479 0 : SgOmpUnifiedAddressClause* tmp = new SgOmpUnifiedAddressClause ( *storageArray ) ;
37480 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37481 0 : storageArray++ ;
37482 : }
37483 : }
37484 0 : delete [] storageArraySgOmpUnifiedAddressClause;
37485 2 : SgOmpUnifiedAddressClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37486 :
37487 :
37488 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUnifiedSharedMemoryClause );
37489 2 : SgOmpUnifiedSharedMemoryClauseStorageClass* storageArraySgOmpUnifiedSharedMemoryClause = NULL;
37490 2 : if ( 0 < sizeOfActualPool )
37491 : {
37492 0 : storageArraySgOmpUnifiedSharedMemoryClause = new SgOmpUnifiedSharedMemoryClauseStorageClass[sizeOfActualPool] ;
37493 0 : inFile.read ( (char*) (storageArraySgOmpUnifiedSharedMemoryClause) , sizeof ( SgOmpUnifiedSharedMemoryClauseStorageClass ) * sizeOfActualPool) ;
37494 0 : SgOmpUnifiedSharedMemoryClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37495 : SgOmpUnifiedSharedMemoryClauseStorageClass* storageArray = storageArraySgOmpUnifiedSharedMemoryClause;
37496 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37497 : {
37498 0 : SgOmpUnifiedSharedMemoryClause* tmp = new SgOmpUnifiedSharedMemoryClause ( *storageArray ) ;
37499 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37500 0 : storageArray++ ;
37501 : }
37502 : }
37503 0 : delete [] storageArraySgOmpUnifiedSharedMemoryClause;
37504 2 : SgOmpUnifiedSharedMemoryClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37505 :
37506 :
37507 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDynamicAllocatorsClause );
37508 2 : SgOmpDynamicAllocatorsClauseStorageClass* storageArraySgOmpDynamicAllocatorsClause = NULL;
37509 2 : if ( 0 < sizeOfActualPool )
37510 : {
37511 0 : storageArraySgOmpDynamicAllocatorsClause = new SgOmpDynamicAllocatorsClauseStorageClass[sizeOfActualPool] ;
37512 0 : inFile.read ( (char*) (storageArraySgOmpDynamicAllocatorsClause) , sizeof ( SgOmpDynamicAllocatorsClauseStorageClass ) * sizeOfActualPool) ;
37513 0 : SgOmpDynamicAllocatorsClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37514 : SgOmpDynamicAllocatorsClauseStorageClass* storageArray = storageArraySgOmpDynamicAllocatorsClause;
37515 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37516 : {
37517 0 : SgOmpDynamicAllocatorsClause* tmp = new SgOmpDynamicAllocatorsClause ( *storageArray ) ;
37518 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37519 0 : storageArray++ ;
37520 : }
37521 : }
37522 0 : delete [] storageArraySgOmpDynamicAllocatorsClause;
37523 2 : SgOmpDynamicAllocatorsClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37524 :
37525 :
37526 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAtomicDefaultMemOrderClause );
37527 2 : SgOmpAtomicDefaultMemOrderClauseStorageClass* storageArraySgOmpAtomicDefaultMemOrderClause = NULL;
37528 2 : if ( 0 < sizeOfActualPool )
37529 : {
37530 0 : storageArraySgOmpAtomicDefaultMemOrderClause = new SgOmpAtomicDefaultMemOrderClauseStorageClass[sizeOfActualPool] ;
37531 0 : inFile.read ( (char*) (storageArraySgOmpAtomicDefaultMemOrderClause) , sizeof ( SgOmpAtomicDefaultMemOrderClauseStorageClass ) * sizeOfActualPool) ;
37532 0 : SgOmpAtomicDefaultMemOrderClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37533 : SgOmpAtomicDefaultMemOrderClauseStorageClass* storageArray = storageArraySgOmpAtomicDefaultMemOrderClause;
37534 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37535 : {
37536 0 : SgOmpAtomicDefaultMemOrderClause* tmp = new SgOmpAtomicDefaultMemOrderClause ( *storageArray ) ;
37537 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37538 0 : storageArray++ ;
37539 : }
37540 : }
37541 0 : delete [] storageArraySgOmpAtomicDefaultMemOrderClause;
37542 2 : SgOmpAtomicDefaultMemOrderClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37543 :
37544 :
37545 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpExtImplementationDefinedRequirementClause );
37546 2 : SgOmpExtImplementationDefinedRequirementClauseStorageClass* storageArraySgOmpExtImplementationDefinedRequirementClause = NULL;
37547 2 : if ( 0 < sizeOfActualPool )
37548 : {
37549 0 : storageArraySgOmpExtImplementationDefinedRequirementClause = new SgOmpExtImplementationDefinedRequirementClauseStorageClass[sizeOfActualPool] ;
37550 0 : inFile.read ( (char*) (storageArraySgOmpExtImplementationDefinedRequirementClause) , sizeof ( SgOmpExtImplementationDefinedRequirementClauseStorageClass ) * sizeOfActualPool) ;
37551 0 : SgOmpExtImplementationDefinedRequirementClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37552 : SgOmpExtImplementationDefinedRequirementClauseStorageClass* storageArray = storageArraySgOmpExtImplementationDefinedRequirementClause;
37553 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37554 : {
37555 0 : SgOmpExtImplementationDefinedRequirementClause* tmp = new SgOmpExtImplementationDefinedRequirementClause ( *storageArray ) ;
37556 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37557 0 : storageArray++ ;
37558 : }
37559 : }
37560 0 : delete [] storageArraySgOmpExtImplementationDefinedRequirementClause;
37561 2 : SgOmpExtImplementationDefinedRequirementClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37562 :
37563 :
37564 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpRelaxedClause );
37565 2 : SgOmpRelaxedClauseStorageClass* storageArraySgOmpRelaxedClause = NULL;
37566 2 : if ( 0 < sizeOfActualPool )
37567 : {
37568 0 : storageArraySgOmpRelaxedClause = new SgOmpRelaxedClauseStorageClass[sizeOfActualPool] ;
37569 0 : inFile.read ( (char*) (storageArraySgOmpRelaxedClause) , sizeof ( SgOmpRelaxedClauseStorageClass ) * sizeOfActualPool) ;
37570 0 : SgOmpRelaxedClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37571 : SgOmpRelaxedClauseStorageClass* storageArray = storageArraySgOmpRelaxedClause;
37572 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37573 : {
37574 0 : SgOmpRelaxedClause* tmp = new SgOmpRelaxedClause ( *storageArray ) ;
37575 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37576 0 : storageArray++ ;
37577 : }
37578 : }
37579 0 : delete [] storageArraySgOmpRelaxedClause;
37580 2 : SgOmpRelaxedClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37581 :
37582 :
37583 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpParallelClause );
37584 2 : SgOmpParallelClauseStorageClass* storageArraySgOmpParallelClause = NULL;
37585 2 : if ( 0 < sizeOfActualPool )
37586 : {
37587 0 : storageArraySgOmpParallelClause = new SgOmpParallelClauseStorageClass[sizeOfActualPool] ;
37588 0 : inFile.read ( (char*) (storageArraySgOmpParallelClause) , sizeof ( SgOmpParallelClauseStorageClass ) * sizeOfActualPool) ;
37589 0 : SgOmpParallelClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37590 : SgOmpParallelClauseStorageClass* storageArray = storageArraySgOmpParallelClause;
37591 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37592 : {
37593 0 : SgOmpParallelClause* tmp = new SgOmpParallelClause ( *storageArray ) ;
37594 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37595 0 : storageArray++ ;
37596 : }
37597 : }
37598 0 : delete [] storageArraySgOmpParallelClause;
37599 2 : SgOmpParallelClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37600 :
37601 :
37602 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSectionsClause );
37603 2 : SgOmpSectionsClauseStorageClass* storageArraySgOmpSectionsClause = NULL;
37604 2 : if ( 0 < sizeOfActualPool )
37605 : {
37606 0 : storageArraySgOmpSectionsClause = new SgOmpSectionsClauseStorageClass[sizeOfActualPool] ;
37607 0 : inFile.read ( (char*) (storageArraySgOmpSectionsClause) , sizeof ( SgOmpSectionsClauseStorageClass ) * sizeOfActualPool) ;
37608 0 : SgOmpSectionsClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37609 : SgOmpSectionsClauseStorageClass* storageArray = storageArraySgOmpSectionsClause;
37610 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37611 : {
37612 0 : SgOmpSectionsClause* tmp = new SgOmpSectionsClause ( *storageArray ) ;
37613 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37614 0 : storageArray++ ;
37615 : }
37616 : }
37617 0 : delete [] storageArraySgOmpSectionsClause;
37618 2 : SgOmpSectionsClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37619 :
37620 :
37621 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpForClause );
37622 2 : SgOmpForClauseStorageClass* storageArraySgOmpForClause = NULL;
37623 2 : if ( 0 < sizeOfActualPool )
37624 : {
37625 0 : storageArraySgOmpForClause = new SgOmpForClauseStorageClass[sizeOfActualPool] ;
37626 0 : inFile.read ( (char*) (storageArraySgOmpForClause) , sizeof ( SgOmpForClauseStorageClass ) * sizeOfActualPool) ;
37627 0 : SgOmpForClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37628 : SgOmpForClauseStorageClass* storageArray = storageArraySgOmpForClause;
37629 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37630 : {
37631 0 : SgOmpForClause* tmp = new SgOmpForClause ( *storageArray ) ;
37632 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37633 0 : storageArray++ ;
37634 : }
37635 : }
37636 0 : delete [] storageArraySgOmpForClause;
37637 2 : SgOmpForClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37638 :
37639 :
37640 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskgroupClause );
37641 2 : SgOmpTaskgroupClauseStorageClass* storageArraySgOmpTaskgroupClause = NULL;
37642 2 : if ( 0 < sizeOfActualPool )
37643 : {
37644 0 : storageArraySgOmpTaskgroupClause = new SgOmpTaskgroupClauseStorageClass[sizeOfActualPool] ;
37645 0 : inFile.read ( (char*) (storageArraySgOmpTaskgroupClause) , sizeof ( SgOmpTaskgroupClauseStorageClass ) * sizeOfActualPool) ;
37646 0 : SgOmpTaskgroupClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37647 : SgOmpTaskgroupClauseStorageClass* storageArray = storageArraySgOmpTaskgroupClause;
37648 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37649 : {
37650 0 : SgOmpTaskgroupClause* tmp = new SgOmpTaskgroupClause ( *storageArray ) ;
37651 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37652 0 : storageArray++ ;
37653 : }
37654 : }
37655 0 : delete [] storageArraySgOmpTaskgroupClause;
37656 2 : SgOmpTaskgroupClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37657 :
37658 :
37659 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirNumUnitsField );
37660 2 : SgUpirNumUnitsFieldStorageClass* storageArraySgUpirNumUnitsField = NULL;
37661 2 : if ( 0 < sizeOfActualPool )
37662 : {
37663 0 : storageArraySgUpirNumUnitsField = new SgUpirNumUnitsFieldStorageClass[sizeOfActualPool] ;
37664 0 : inFile.read ( (char*) (storageArraySgUpirNumUnitsField) , sizeof ( SgUpirNumUnitsFieldStorageClass ) * sizeOfActualPool) ;
37665 0 : SgUpirNumUnitsFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
37666 : SgUpirNumUnitsFieldStorageClass* storageArray = storageArraySgUpirNumUnitsField;
37667 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37668 : {
37669 0 : SgUpirNumUnitsField* tmp = new SgUpirNumUnitsField ( *storageArray ) ;
37670 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37671 0 : storageArray++ ;
37672 : }
37673 : }
37674 0 : delete [] storageArraySgUpirNumUnitsField;
37675 2 : SgUpirNumUnitsFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
37676 :
37677 :
37678 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNumTeamsClause );
37679 2 : SgOmpNumTeamsClauseStorageClass* storageArraySgOmpNumTeamsClause = NULL;
37680 2 : if ( 0 < sizeOfActualPool )
37681 : {
37682 0 : storageArraySgOmpNumTeamsClause = new SgOmpNumTeamsClauseStorageClass[sizeOfActualPool] ;
37683 0 : inFile.read ( (char*) (storageArraySgOmpNumTeamsClause) , sizeof ( SgOmpNumTeamsClauseStorageClass ) * sizeOfActualPool) ;
37684 0 : SgOmpNumTeamsClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37685 : SgOmpNumTeamsClauseStorageClass* storageArray = storageArraySgOmpNumTeamsClause;
37686 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37687 : {
37688 0 : SgOmpNumTeamsClause* tmp = new SgOmpNumTeamsClause ( *storageArray ) ;
37689 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37690 0 : storageArray++ ;
37691 : }
37692 : }
37693 0 : delete [] storageArraySgOmpNumTeamsClause;
37694 2 : SgOmpNumTeamsClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37695 :
37696 :
37697 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpGrainsizeClause );
37698 2 : SgOmpGrainsizeClauseStorageClass* storageArraySgOmpGrainsizeClause = NULL;
37699 2 : if ( 0 < sizeOfActualPool )
37700 : {
37701 0 : storageArraySgOmpGrainsizeClause = new SgOmpGrainsizeClauseStorageClass[sizeOfActualPool] ;
37702 0 : inFile.read ( (char*) (storageArraySgOmpGrainsizeClause) , sizeof ( SgOmpGrainsizeClauseStorageClass ) * sizeOfActualPool) ;
37703 0 : SgOmpGrainsizeClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37704 : SgOmpGrainsizeClauseStorageClass* storageArray = storageArraySgOmpGrainsizeClause;
37705 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37706 : {
37707 0 : SgOmpGrainsizeClause* tmp = new SgOmpGrainsizeClause ( *storageArray ) ;
37708 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37709 0 : storageArray++ ;
37710 : }
37711 : }
37712 0 : delete [] storageArraySgOmpGrainsizeClause;
37713 2 : SgOmpGrainsizeClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37714 :
37715 :
37716 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDetachClause );
37717 2 : SgOmpDetachClauseStorageClass* storageArraySgOmpDetachClause = NULL;
37718 2 : if ( 0 < sizeOfActualPool )
37719 : {
37720 0 : storageArraySgOmpDetachClause = new SgOmpDetachClauseStorageClass[sizeOfActualPool] ;
37721 0 : inFile.read ( (char*) (storageArraySgOmpDetachClause) , sizeof ( SgOmpDetachClauseStorageClass ) * sizeOfActualPool) ;
37722 0 : SgOmpDetachClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37723 : SgOmpDetachClauseStorageClass* storageArray = storageArraySgOmpDetachClause;
37724 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37725 : {
37726 0 : SgOmpDetachClause* tmp = new SgOmpDetachClause ( *storageArray ) ;
37727 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37728 0 : storageArray++ ;
37729 : }
37730 : }
37731 0 : delete [] storageArraySgOmpDetachClause;
37732 2 : SgOmpDetachClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37733 :
37734 :
37735 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNumTasksClause );
37736 2 : SgOmpNumTasksClauseStorageClass* storageArraySgOmpNumTasksClause = NULL;
37737 2 : if ( 0 < sizeOfActualPool )
37738 : {
37739 0 : storageArraySgOmpNumTasksClause = new SgOmpNumTasksClauseStorageClass[sizeOfActualPool] ;
37740 0 : inFile.read ( (char*) (storageArraySgOmpNumTasksClause) , sizeof ( SgOmpNumTasksClauseStorageClass ) * sizeOfActualPool) ;
37741 0 : SgOmpNumTasksClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37742 : SgOmpNumTasksClauseStorageClass* storageArray = storageArraySgOmpNumTasksClause;
37743 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37744 : {
37745 0 : SgOmpNumTasksClause* tmp = new SgOmpNumTasksClause ( *storageArray ) ;
37746 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37747 0 : storageArray++ ;
37748 : }
37749 : }
37750 0 : delete [] storageArraySgOmpNumTasksClause;
37751 2 : SgOmpNumTasksClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37752 :
37753 :
37754 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNogroupClause );
37755 2 : SgOmpNogroupClauseStorageClass* storageArraySgOmpNogroupClause = NULL;
37756 2 : if ( 0 < sizeOfActualPool )
37757 : {
37758 0 : storageArraySgOmpNogroupClause = new SgOmpNogroupClauseStorageClass[sizeOfActualPool] ;
37759 0 : inFile.read ( (char*) (storageArraySgOmpNogroupClause) , sizeof ( SgOmpNogroupClauseStorageClass ) * sizeOfActualPool) ;
37760 0 : SgOmpNogroupClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37761 : SgOmpNogroupClauseStorageClass* storageArray = storageArraySgOmpNogroupClause;
37762 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37763 : {
37764 0 : SgOmpNogroupClause* tmp = new SgOmpNogroupClause ( *storageArray ) ;
37765 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37766 0 : storageArray++ ;
37767 : }
37768 : }
37769 0 : delete [] storageArraySgOmpNogroupClause;
37770 2 : SgOmpNogroupClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37771 :
37772 :
37773 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpHintClause );
37774 2 : SgOmpHintClauseStorageClass* storageArraySgOmpHintClause = NULL;
37775 2 : if ( 0 < sizeOfActualPool )
37776 : {
37777 0 : storageArraySgOmpHintClause = new SgOmpHintClauseStorageClass[sizeOfActualPool] ;
37778 0 : inFile.read ( (char*) (storageArraySgOmpHintClause) , sizeof ( SgOmpHintClauseStorageClass ) * sizeOfActualPool) ;
37779 0 : SgOmpHintClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37780 : SgOmpHintClauseStorageClass* storageArray = storageArraySgOmpHintClause;
37781 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37782 : {
37783 0 : SgOmpHintClause* tmp = new SgOmpHintClause ( *storageArray ) ;
37784 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37785 0 : storageArray++ ;
37786 : }
37787 : }
37788 0 : delete [] storageArraySgOmpHintClause;
37789 2 : SgOmpHintClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37790 :
37791 :
37792 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpOrderClause );
37793 2 : SgOmpOrderClauseStorageClass* storageArraySgOmpOrderClause = NULL;
37794 2 : if ( 0 < sizeOfActualPool )
37795 : {
37796 0 : storageArraySgOmpOrderClause = new SgOmpOrderClauseStorageClass[sizeOfActualPool] ;
37797 0 : inFile.read ( (char*) (storageArraySgOmpOrderClause) , sizeof ( SgOmpOrderClauseStorageClass ) * sizeOfActualPool) ;
37798 0 : SgOmpOrderClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37799 : SgOmpOrderClauseStorageClass* storageArray = storageArraySgOmpOrderClause;
37800 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37801 : {
37802 0 : SgOmpOrderClause* tmp = new SgOmpOrderClause ( *storageArray ) ;
37803 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37804 0 : storageArray++ ;
37805 : }
37806 : }
37807 0 : delete [] storageArraySgOmpOrderClause;
37808 2 : SgOmpOrderClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37809 :
37810 :
37811 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDistScheduleClause );
37812 2 : SgOmpDistScheduleClauseStorageClass* storageArraySgOmpDistScheduleClause = NULL;
37813 2 : if ( 0 < sizeOfActualPool )
37814 : {
37815 0 : storageArraySgOmpDistScheduleClause = new SgOmpDistScheduleClauseStorageClass[sizeOfActualPool] ;
37816 0 : inFile.read ( (char*) (storageArraySgOmpDistScheduleClause) , sizeof ( SgOmpDistScheduleClauseStorageClass ) * sizeOfActualPool) ;
37817 0 : SgOmpDistScheduleClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37818 : SgOmpDistScheduleClauseStorageClass* storageArray = storageArraySgOmpDistScheduleClause;
37819 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37820 : {
37821 0 : SgOmpDistScheduleClause* tmp = new SgOmpDistScheduleClause ( *storageArray ) ;
37822 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37823 0 : storageArray++ ;
37824 : }
37825 : }
37826 0 : delete [] storageArraySgOmpDistScheduleClause;
37827 2 : SgOmpDistScheduleClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37828 :
37829 :
37830 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpBindClause );
37831 2 : SgOmpBindClauseStorageClass* storageArraySgOmpBindClause = NULL;
37832 2 : if ( 0 < sizeOfActualPool )
37833 : {
37834 0 : storageArraySgOmpBindClause = new SgOmpBindClauseStorageClass[sizeOfActualPool] ;
37835 0 : inFile.read ( (char*) (storageArraySgOmpBindClause) , sizeof ( SgOmpBindClauseStorageClass ) * sizeOfActualPool) ;
37836 0 : SgOmpBindClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37837 : SgOmpBindClauseStorageClass* storageArray = storageArraySgOmpBindClause;
37838 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37839 : {
37840 0 : SgOmpBindClause* tmp = new SgOmpBindClause ( *storageArray ) ;
37841 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37842 0 : storageArray++ ;
37843 : }
37844 : }
37845 0 : delete [] storageArraySgOmpBindClause;
37846 2 : SgOmpBindClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37847 :
37848 :
37849 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNontemporalClause );
37850 2 : SgOmpNontemporalClauseStorageClass* storageArraySgOmpNontemporalClause = NULL;
37851 2 : if ( 0 < sizeOfActualPool )
37852 : {
37853 0 : storageArraySgOmpNontemporalClause = new SgOmpNontemporalClauseStorageClass[sizeOfActualPool] ;
37854 0 : inFile.read ( (char*) (storageArraySgOmpNontemporalClause) , sizeof ( SgOmpNontemporalClauseStorageClass ) * sizeOfActualPool) ;
37855 0 : SgOmpNontemporalClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37856 : SgOmpNontemporalClauseStorageClass* storageArray = storageArraySgOmpNontemporalClause;
37857 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37858 : {
37859 0 : SgOmpNontemporalClause* tmp = new SgOmpNontemporalClause ( *storageArray ) ;
37860 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37861 0 : storageArray++ ;
37862 : }
37863 : }
37864 0 : delete [] storageArraySgOmpNontemporalClause;
37865 2 : SgOmpNontemporalClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37866 :
37867 :
37868 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpInclusiveClause );
37869 2 : SgOmpInclusiveClauseStorageClass* storageArraySgOmpInclusiveClause = NULL;
37870 2 : if ( 0 < sizeOfActualPool )
37871 : {
37872 0 : storageArraySgOmpInclusiveClause = new SgOmpInclusiveClauseStorageClass[sizeOfActualPool] ;
37873 0 : inFile.read ( (char*) (storageArraySgOmpInclusiveClause) , sizeof ( SgOmpInclusiveClauseStorageClass ) * sizeOfActualPool) ;
37874 0 : SgOmpInclusiveClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37875 : SgOmpInclusiveClauseStorageClass* storageArray = storageArraySgOmpInclusiveClause;
37876 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37877 : {
37878 0 : SgOmpInclusiveClause* tmp = new SgOmpInclusiveClause ( *storageArray ) ;
37879 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37880 0 : storageArray++ ;
37881 : }
37882 : }
37883 0 : delete [] storageArraySgOmpInclusiveClause;
37884 2 : SgOmpInclusiveClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37885 :
37886 :
37887 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpExclusiveClause );
37888 2 : SgOmpExclusiveClauseStorageClass* storageArraySgOmpExclusiveClause = NULL;
37889 2 : if ( 0 < sizeOfActualPool )
37890 : {
37891 0 : storageArraySgOmpExclusiveClause = new SgOmpExclusiveClauseStorageClass[sizeOfActualPool] ;
37892 0 : inFile.read ( (char*) (storageArraySgOmpExclusiveClause) , sizeof ( SgOmpExclusiveClauseStorageClass ) * sizeOfActualPool) ;
37893 0 : SgOmpExclusiveClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37894 : SgOmpExclusiveClauseStorageClass* storageArray = storageArraySgOmpExclusiveClause;
37895 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37896 : {
37897 0 : SgOmpExclusiveClause* tmp = new SgOmpExclusiveClause ( *storageArray ) ;
37898 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37899 0 : storageArray++ ;
37900 : }
37901 : }
37902 0 : delete [] storageArraySgOmpExclusiveClause;
37903 2 : SgOmpExclusiveClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37904 :
37905 :
37906 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpIsDevicePtrClause );
37907 2 : SgOmpIsDevicePtrClauseStorageClass* storageArraySgOmpIsDevicePtrClause = NULL;
37908 2 : if ( 0 < sizeOfActualPool )
37909 : {
37910 0 : storageArraySgOmpIsDevicePtrClause = new SgOmpIsDevicePtrClauseStorageClass[sizeOfActualPool] ;
37911 0 : inFile.read ( (char*) (storageArraySgOmpIsDevicePtrClause) , sizeof ( SgOmpIsDevicePtrClauseStorageClass ) * sizeOfActualPool) ;
37912 0 : SgOmpIsDevicePtrClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37913 : SgOmpIsDevicePtrClauseStorageClass* storageArray = storageArraySgOmpIsDevicePtrClause;
37914 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37915 : {
37916 0 : SgOmpIsDevicePtrClause* tmp = new SgOmpIsDevicePtrClause ( *storageArray ) ;
37917 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37918 0 : storageArray++ ;
37919 : }
37920 : }
37921 0 : delete [] storageArraySgOmpIsDevicePtrClause;
37922 2 : SgOmpIsDevicePtrClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37923 :
37924 :
37925 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUseDevicePtrClause );
37926 2 : SgOmpUseDevicePtrClauseStorageClass* storageArraySgOmpUseDevicePtrClause = NULL;
37927 2 : if ( 0 < sizeOfActualPool )
37928 : {
37929 0 : storageArraySgOmpUseDevicePtrClause = new SgOmpUseDevicePtrClauseStorageClass[sizeOfActualPool] ;
37930 0 : inFile.read ( (char*) (storageArraySgOmpUseDevicePtrClause) , sizeof ( SgOmpUseDevicePtrClauseStorageClass ) * sizeOfActualPool) ;
37931 0 : SgOmpUseDevicePtrClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37932 : SgOmpUseDevicePtrClauseStorageClass* storageArray = storageArraySgOmpUseDevicePtrClause;
37933 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37934 : {
37935 0 : SgOmpUseDevicePtrClause* tmp = new SgOmpUseDevicePtrClause ( *storageArray ) ;
37936 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37937 0 : storageArray++ ;
37938 : }
37939 : }
37940 0 : delete [] storageArraySgOmpUseDevicePtrClause;
37941 2 : SgOmpUseDevicePtrClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37942 :
37943 :
37944 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUseDeviceAddrClause );
37945 2 : SgOmpUseDeviceAddrClauseStorageClass* storageArraySgOmpUseDeviceAddrClause = NULL;
37946 2 : if ( 0 < sizeOfActualPool )
37947 : {
37948 0 : storageArraySgOmpUseDeviceAddrClause = new SgOmpUseDeviceAddrClauseStorageClass[sizeOfActualPool] ;
37949 0 : inFile.read ( (char*) (storageArraySgOmpUseDeviceAddrClause) , sizeof ( SgOmpUseDeviceAddrClauseStorageClass ) * sizeOfActualPool) ;
37950 0 : SgOmpUseDeviceAddrClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37951 : SgOmpUseDeviceAddrClauseStorageClass* storageArray = storageArraySgOmpUseDeviceAddrClause;
37952 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37953 : {
37954 0 : SgOmpUseDeviceAddrClause* tmp = new SgOmpUseDeviceAddrClause ( *storageArray ) ;
37955 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37956 0 : storageArray++ ;
37957 : }
37958 : }
37959 0 : delete [] storageArraySgOmpUseDeviceAddrClause;
37960 2 : SgOmpUseDeviceAddrClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37961 :
37962 :
37963 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpThreadLimitClause );
37964 2 : SgOmpThreadLimitClauseStorageClass* storageArraySgOmpThreadLimitClause = NULL;
37965 2 : if ( 0 < sizeOfActualPool )
37966 : {
37967 0 : storageArraySgOmpThreadLimitClause = new SgOmpThreadLimitClauseStorageClass[sizeOfActualPool] ;
37968 0 : inFile.read ( (char*) (storageArraySgOmpThreadLimitClause) , sizeof ( SgOmpThreadLimitClauseStorageClass ) * sizeOfActualPool) ;
37969 0 : SgOmpThreadLimitClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37970 : SgOmpThreadLimitClauseStorageClass* storageArray = storageArraySgOmpThreadLimitClause;
37971 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37972 : {
37973 0 : SgOmpThreadLimitClause* tmp = new SgOmpThreadLimitClause ( *storageArray ) ;
37974 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37975 0 : storageArray++ ;
37976 : }
37977 : }
37978 0 : delete [] storageArraySgOmpThreadLimitClause;
37979 2 : SgOmpThreadLimitClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37980 :
37981 :
37982 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpOrderedClause );
37983 2 : SgOmpOrderedClauseStorageClass* storageArraySgOmpOrderedClause = NULL;
37984 2 : if ( 0 < sizeOfActualPool )
37985 : {
37986 0 : storageArraySgOmpOrderedClause = new SgOmpOrderedClauseStorageClass[sizeOfActualPool] ;
37987 0 : inFile.read ( (char*) (storageArraySgOmpOrderedClause) , sizeof ( SgOmpOrderedClauseStorageClass ) * sizeOfActualPool) ;
37988 0 : SgOmpOrderedClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
37989 : SgOmpOrderedClauseStorageClass* storageArray = storageArraySgOmpOrderedClause;
37990 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
37991 : {
37992 0 : SgOmpOrderedClause* tmp = new SgOmpOrderedClause ( *storageArray ) ;
37993 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
37994 0 : storageArray++ ;
37995 : }
37996 : }
37997 0 : delete [] storageArraySgOmpOrderedClause;
37998 2 : SgOmpOrderedClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
37999 :
38000 :
38001 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpPrivateClause );
38002 2 : SgOmpPrivateClauseStorageClass* storageArraySgOmpPrivateClause = NULL;
38003 2 : if ( 0 < sizeOfActualPool )
38004 : {
38005 0 : storageArraySgOmpPrivateClause = new SgOmpPrivateClauseStorageClass[sizeOfActualPool] ;
38006 0 : inFile.read ( (char*) (storageArraySgOmpPrivateClause) , sizeof ( SgOmpPrivateClauseStorageClass ) * sizeOfActualPool) ;
38007 0 : SgOmpPrivateClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38008 : SgOmpPrivateClauseStorageClass* storageArray = storageArraySgOmpPrivateClause;
38009 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38010 : {
38011 0 : SgOmpPrivateClause* tmp = new SgOmpPrivateClause ( *storageArray ) ;
38012 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38013 0 : storageArray++ ;
38014 : }
38015 : }
38016 0 : delete [] storageArraySgOmpPrivateClause;
38017 2 : SgOmpPrivateClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38018 :
38019 :
38020 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpReductionClause );
38021 2 : SgOmpReductionClauseStorageClass* storageArraySgOmpReductionClause = NULL;
38022 2 : if ( 0 < sizeOfActualPool )
38023 : {
38024 0 : storageArraySgOmpReductionClause = new SgOmpReductionClauseStorageClass[sizeOfActualPool] ;
38025 0 : inFile.read ( (char*) (storageArraySgOmpReductionClause) , sizeof ( SgOmpReductionClauseStorageClass ) * sizeOfActualPool) ;
38026 0 : SgOmpReductionClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38027 : SgOmpReductionClauseStorageClass* storageArray = storageArraySgOmpReductionClause;
38028 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38029 : {
38030 0 : SgOmpReductionClause* tmp = new SgOmpReductionClause ( *storageArray ) ;
38031 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38032 0 : storageArray++ ;
38033 : }
38034 : }
38035 0 : delete [] storageArraySgOmpReductionClause;
38036 2 : SgOmpReductionClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38037 :
38038 :
38039 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpInReductionClause );
38040 2 : SgOmpInReductionClauseStorageClass* storageArraySgOmpInReductionClause = NULL;
38041 2 : if ( 0 < sizeOfActualPool )
38042 : {
38043 0 : storageArraySgOmpInReductionClause = new SgOmpInReductionClauseStorageClass[sizeOfActualPool] ;
38044 0 : inFile.read ( (char*) (storageArraySgOmpInReductionClause) , sizeof ( SgOmpInReductionClauseStorageClass ) * sizeOfActualPool) ;
38045 0 : SgOmpInReductionClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38046 : SgOmpInReductionClauseStorageClass* storageArray = storageArraySgOmpInReductionClause;
38047 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38048 : {
38049 0 : SgOmpInReductionClause* tmp = new SgOmpInReductionClause ( *storageArray ) ;
38050 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38051 0 : storageArray++ ;
38052 : }
38053 : }
38054 0 : delete [] storageArraySgOmpInReductionClause;
38055 2 : SgOmpInReductionClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38056 :
38057 :
38058 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpTaskReductionClause );
38059 2 : SgOmpTaskReductionClauseStorageClass* storageArraySgOmpTaskReductionClause = NULL;
38060 2 : if ( 0 < sizeOfActualPool )
38061 : {
38062 0 : storageArraySgOmpTaskReductionClause = new SgOmpTaskReductionClauseStorageClass[sizeOfActualPool] ;
38063 0 : inFile.read ( (char*) (storageArraySgOmpTaskReductionClause) , sizeof ( SgOmpTaskReductionClauseStorageClass ) * sizeOfActualPool) ;
38064 0 : SgOmpTaskReductionClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38065 : SgOmpTaskReductionClauseStorageClass* storageArray = storageArraySgOmpTaskReductionClause;
38066 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38067 : {
38068 0 : SgOmpTaskReductionClause* tmp = new SgOmpTaskReductionClause ( *storageArray ) ;
38069 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38070 0 : storageArray++ ;
38071 : }
38072 : }
38073 0 : delete [] storageArraySgOmpTaskReductionClause;
38074 2 : SgOmpTaskReductionClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38075 :
38076 :
38077 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDefaultmapClause );
38078 2 : SgOmpDefaultmapClauseStorageClass* storageArraySgOmpDefaultmapClause = NULL;
38079 2 : if ( 0 < sizeOfActualPool )
38080 : {
38081 0 : storageArraySgOmpDefaultmapClause = new SgOmpDefaultmapClauseStorageClass[sizeOfActualPool] ;
38082 0 : inFile.read ( (char*) (storageArraySgOmpDefaultmapClause) , sizeof ( SgOmpDefaultmapClauseStorageClass ) * sizeOfActualPool) ;
38083 0 : SgOmpDefaultmapClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38084 : SgOmpDefaultmapClauseStorageClass* storageArray = storageArraySgOmpDefaultmapClause;
38085 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38086 : {
38087 0 : SgOmpDefaultmapClause* tmp = new SgOmpDefaultmapClause ( *storageArray ) ;
38088 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38089 0 : storageArray++ ;
38090 : }
38091 : }
38092 0 : delete [] storageArraySgOmpDefaultmapClause;
38093 2 : SgOmpDefaultmapClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38094 :
38095 :
38096 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpScheduleClause );
38097 2 : SgOmpScheduleClauseStorageClass* storageArraySgOmpScheduleClause = NULL;
38098 2 : if ( 0 < sizeOfActualPool )
38099 : {
38100 0 : storageArraySgOmpScheduleClause = new SgOmpScheduleClauseStorageClass[sizeOfActualPool] ;
38101 0 : inFile.read ( (char*) (storageArraySgOmpScheduleClause) , sizeof ( SgOmpScheduleClauseStorageClass ) * sizeOfActualPool) ;
38102 0 : SgOmpScheduleClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38103 : SgOmpScheduleClauseStorageClass* storageArray = storageArraySgOmpScheduleClause;
38104 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38105 : {
38106 0 : SgOmpScheduleClause* tmp = new SgOmpScheduleClause ( *storageArray ) ;
38107 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38108 0 : storageArray++ ;
38109 : }
38110 : }
38111 0 : delete [] storageArraySgOmpScheduleClause;
38112 2 : SgOmpScheduleClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38113 :
38114 :
38115 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSharedClause );
38116 2 : SgOmpSharedClauseStorageClass* storageArraySgOmpSharedClause = NULL;
38117 2 : if ( 0 < sizeOfActualPool )
38118 : {
38119 0 : storageArraySgOmpSharedClause = new SgOmpSharedClauseStorageClass[sizeOfActualPool] ;
38120 0 : inFile.read ( (char*) (storageArraySgOmpSharedClause) , sizeof ( SgOmpSharedClauseStorageClass ) * sizeOfActualPool) ;
38121 0 : SgOmpSharedClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38122 : SgOmpSharedClauseStorageClass* storageArray = storageArraySgOmpSharedClause;
38123 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38124 : {
38125 0 : SgOmpSharedClause* tmp = new SgOmpSharedClause ( *storageArray ) ;
38126 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38127 0 : storageArray++ ;
38128 : }
38129 : }
38130 0 : delete [] storageArraySgOmpSharedClause;
38131 2 : SgOmpSharedClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38132 :
38133 :
38134 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUntiedClause );
38135 2 : SgOmpUntiedClauseStorageClass* storageArraySgOmpUntiedClause = NULL;
38136 2 : if ( 0 < sizeOfActualPool )
38137 : {
38138 0 : storageArraySgOmpUntiedClause = new SgOmpUntiedClauseStorageClass[sizeOfActualPool] ;
38139 0 : inFile.read ( (char*) (storageArraySgOmpUntiedClause) , sizeof ( SgOmpUntiedClauseStorageClass ) * sizeOfActualPool) ;
38140 0 : SgOmpUntiedClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38141 : SgOmpUntiedClauseStorageClass* storageArray = storageArraySgOmpUntiedClause;
38142 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38143 : {
38144 0 : SgOmpUntiedClause* tmp = new SgOmpUntiedClause ( *storageArray ) ;
38145 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38146 0 : storageArray++ ;
38147 : }
38148 : }
38149 0 : delete [] storageArraySgOmpUntiedClause;
38150 2 : SgOmpUntiedClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38151 :
38152 :
38153 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMergeableClause );
38154 2 : SgOmpMergeableClauseStorageClass* storageArraySgOmpMergeableClause = NULL;
38155 2 : if ( 0 < sizeOfActualPool )
38156 : {
38157 0 : storageArraySgOmpMergeableClause = new SgOmpMergeableClauseStorageClass[sizeOfActualPool] ;
38158 0 : inFile.read ( (char*) (storageArraySgOmpMergeableClause) , sizeof ( SgOmpMergeableClauseStorageClass ) * sizeOfActualPool) ;
38159 0 : SgOmpMergeableClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38160 : SgOmpMergeableClauseStorageClass* storageArray = storageArraySgOmpMergeableClause;
38161 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38162 : {
38163 0 : SgOmpMergeableClause* tmp = new SgOmpMergeableClause ( *storageArray ) ;
38164 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38165 0 : storageArray++ ;
38166 : }
38167 : }
38168 0 : delete [] storageArraySgOmpMergeableClause;
38169 2 : SgOmpMergeableClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38170 :
38171 :
38172 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpVariablesClause );
38173 2 : SgOmpVariablesClauseStorageClass* storageArraySgOmpVariablesClause = NULL;
38174 2 : if ( 0 < sizeOfActualPool )
38175 : {
38176 0 : storageArraySgOmpVariablesClause = new SgOmpVariablesClauseStorageClass[sizeOfActualPool] ;
38177 0 : inFile.read ( (char*) (storageArraySgOmpVariablesClause) , sizeof ( SgOmpVariablesClauseStorageClass ) * sizeOfActualPool) ;
38178 0 : SgOmpVariablesClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38179 : SgOmpVariablesClauseStorageClass* storageArray = storageArraySgOmpVariablesClause;
38180 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38181 : {
38182 0 : SgOmpVariablesClause* tmp = new SgOmpVariablesClause ( *storageArray ) ;
38183 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38184 0 : storageArray++ ;
38185 : }
38186 : }
38187 0 : delete [] storageArraySgOmpVariablesClause;
38188 2 : SgOmpVariablesClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38189 :
38190 :
38191 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpMapClause );
38192 2 : SgOmpMapClauseStorageClass* storageArraySgOmpMapClause = NULL;
38193 2 : if ( 0 < sizeOfActualPool )
38194 : {
38195 0 : storageArraySgOmpMapClause = new SgOmpMapClauseStorageClass[sizeOfActualPool] ;
38196 0 : inFile.read ( (char*) (storageArraySgOmpMapClause) , sizeof ( SgOmpMapClauseStorageClass ) * sizeOfActualPool) ;
38197 0 : SgOmpMapClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38198 : SgOmpMapClauseStorageClass* storageArray = storageArraySgOmpMapClause;
38199 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38200 : {
38201 0 : SgOmpMapClause* tmp = new SgOmpMapClause ( *storageArray ) ;
38202 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38203 0 : storageArray++ ;
38204 : }
38205 : }
38206 0 : delete [] storageArraySgOmpMapClause;
38207 2 : SgOmpMapClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38208 :
38209 :
38210 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSafelenClause );
38211 2 : SgOmpSafelenClauseStorageClass* storageArraySgOmpSafelenClause = NULL;
38212 2 : if ( 0 < sizeOfActualPool )
38213 : {
38214 0 : storageArraySgOmpSafelenClause = new SgOmpSafelenClauseStorageClass[sizeOfActualPool] ;
38215 0 : inFile.read ( (char*) (storageArraySgOmpSafelenClause) , sizeof ( SgOmpSafelenClauseStorageClass ) * sizeOfActualPool) ;
38216 0 : SgOmpSafelenClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38217 : SgOmpSafelenClauseStorageClass* storageArray = storageArraySgOmpSafelenClause;
38218 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38219 : {
38220 0 : SgOmpSafelenClause* tmp = new SgOmpSafelenClause ( *storageArray ) ;
38221 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38222 0 : storageArray++ ;
38223 : }
38224 : }
38225 0 : delete [] storageArraySgOmpSafelenClause;
38226 2 : SgOmpSafelenClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38227 :
38228 :
38229 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSimdlenClause );
38230 2 : SgOmpSimdlenClauseStorageClass* storageArraySgOmpSimdlenClause = NULL;
38231 2 : if ( 0 < sizeOfActualPool )
38232 : {
38233 0 : storageArraySgOmpSimdlenClause = new SgOmpSimdlenClauseStorageClass[sizeOfActualPool] ;
38234 0 : inFile.read ( (char*) (storageArraySgOmpSimdlenClause) , sizeof ( SgOmpSimdlenClauseStorageClass ) * sizeOfActualPool) ;
38235 0 : SgOmpSimdlenClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38236 : SgOmpSimdlenClauseStorageClass* storageArray = storageArraySgOmpSimdlenClause;
38237 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38238 : {
38239 0 : SgOmpSimdlenClause* tmp = new SgOmpSimdlenClause ( *storageArray ) ;
38240 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38241 0 : storageArray++ ;
38242 : }
38243 : }
38244 0 : delete [] storageArraySgOmpSimdlenClause;
38245 2 : SgOmpSimdlenClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38246 :
38247 :
38248 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpLinearClause );
38249 2 : SgOmpLinearClauseStorageClass* storageArraySgOmpLinearClause = NULL;
38250 2 : if ( 0 < sizeOfActualPool )
38251 : {
38252 0 : storageArraySgOmpLinearClause = new SgOmpLinearClauseStorageClass[sizeOfActualPool] ;
38253 0 : inFile.read ( (char*) (storageArraySgOmpLinearClause) , sizeof ( SgOmpLinearClauseStorageClass ) * sizeOfActualPool) ;
38254 0 : SgOmpLinearClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38255 : SgOmpLinearClauseStorageClass* storageArray = storageArraySgOmpLinearClause;
38256 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38257 : {
38258 0 : SgOmpLinearClause* tmp = new SgOmpLinearClause ( *storageArray ) ;
38259 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38260 0 : storageArray++ ;
38261 : }
38262 : }
38263 0 : delete [] storageArraySgOmpLinearClause;
38264 2 : SgOmpLinearClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38265 :
38266 :
38267 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpUniformClause );
38268 2 : SgOmpUniformClauseStorageClass* storageArraySgOmpUniformClause = NULL;
38269 2 : if ( 0 < sizeOfActualPool )
38270 : {
38271 0 : storageArraySgOmpUniformClause = new SgOmpUniformClauseStorageClass[sizeOfActualPool] ;
38272 0 : inFile.read ( (char*) (storageArraySgOmpUniformClause) , sizeof ( SgOmpUniformClauseStorageClass ) * sizeOfActualPool) ;
38273 0 : SgOmpUniformClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38274 : SgOmpUniformClauseStorageClass* storageArray = storageArraySgOmpUniformClause;
38275 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38276 : {
38277 0 : SgOmpUniformClause* tmp = new SgOmpUniformClause ( *storageArray ) ;
38278 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38279 0 : storageArray++ ;
38280 : }
38281 : }
38282 0 : delete [] storageArraySgOmpUniformClause;
38283 2 : SgOmpUniformClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38284 :
38285 :
38286 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAlignedClause );
38287 2 : SgOmpAlignedClauseStorageClass* storageArraySgOmpAlignedClause = NULL;
38288 2 : if ( 0 < sizeOfActualPool )
38289 : {
38290 0 : storageArraySgOmpAlignedClause = new SgOmpAlignedClauseStorageClass[sizeOfActualPool] ;
38291 0 : inFile.read ( (char*) (storageArraySgOmpAlignedClause) , sizeof ( SgOmpAlignedClauseStorageClass ) * sizeOfActualPool) ;
38292 0 : SgOmpAlignedClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38293 : SgOmpAlignedClauseStorageClass* storageArray = storageArraySgOmpAlignedClause;
38294 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38295 : {
38296 0 : SgOmpAlignedClause* tmp = new SgOmpAlignedClause ( *storageArray ) ;
38297 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38298 0 : storageArray++ ;
38299 : }
38300 : }
38301 0 : delete [] storageArraySgOmpAlignedClause;
38302 2 : SgOmpAlignedClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38303 :
38304 :
38305 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpProcBindClause );
38306 2 : SgOmpProcBindClauseStorageClass* storageArraySgOmpProcBindClause = NULL;
38307 2 : if ( 0 < sizeOfActualPool )
38308 : {
38309 0 : storageArraySgOmpProcBindClause = new SgOmpProcBindClauseStorageClass[sizeOfActualPool] ;
38310 0 : inFile.read ( (char*) (storageArraySgOmpProcBindClause) , sizeof ( SgOmpProcBindClauseStorageClass ) * sizeOfActualPool) ;
38311 0 : SgOmpProcBindClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38312 : SgOmpProcBindClauseStorageClass* storageArray = storageArraySgOmpProcBindClause;
38313 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38314 : {
38315 0 : SgOmpProcBindClause* tmp = new SgOmpProcBindClause ( *storageArray ) ;
38316 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38317 0 : storageArray++ ;
38318 : }
38319 : }
38320 0 : delete [] storageArraySgOmpProcBindClause;
38321 2 : SgOmpProcBindClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38322 :
38323 :
38324 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAtomicClause );
38325 2 : SgOmpAtomicClauseStorageClass* storageArraySgOmpAtomicClause = NULL;
38326 2 : if ( 0 < sizeOfActualPool )
38327 : {
38328 0 : storageArraySgOmpAtomicClause = new SgOmpAtomicClauseStorageClass[sizeOfActualPool] ;
38329 0 : inFile.read ( (char*) (storageArraySgOmpAtomicClause) , sizeof ( SgOmpAtomicClauseStorageClass ) * sizeOfActualPool) ;
38330 0 : SgOmpAtomicClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38331 : SgOmpAtomicClauseStorageClass* storageArray = storageArraySgOmpAtomicClause;
38332 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38333 : {
38334 0 : SgOmpAtomicClause* tmp = new SgOmpAtomicClause ( *storageArray ) ;
38335 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38336 0 : storageArray++ ;
38337 : }
38338 : }
38339 0 : delete [] storageArraySgOmpAtomicClause;
38340 2 : SgOmpAtomicClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38341 :
38342 :
38343 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpInbranchClause );
38344 2 : SgOmpInbranchClauseStorageClass* storageArraySgOmpInbranchClause = NULL;
38345 2 : if ( 0 < sizeOfActualPool )
38346 : {
38347 0 : storageArraySgOmpInbranchClause = new SgOmpInbranchClauseStorageClass[sizeOfActualPool] ;
38348 0 : inFile.read ( (char*) (storageArraySgOmpInbranchClause) , sizeof ( SgOmpInbranchClauseStorageClass ) * sizeOfActualPool) ;
38349 0 : SgOmpInbranchClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38350 : SgOmpInbranchClauseStorageClass* storageArray = storageArraySgOmpInbranchClause;
38351 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38352 : {
38353 0 : SgOmpInbranchClause* tmp = new SgOmpInbranchClause ( *storageArray ) ;
38354 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38355 0 : storageArray++ ;
38356 : }
38357 : }
38358 0 : delete [] storageArraySgOmpInbranchClause;
38359 2 : SgOmpInbranchClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38360 :
38361 :
38362 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpNotinbranchClause );
38363 2 : SgOmpNotinbranchClauseStorageClass* storageArraySgOmpNotinbranchClause = NULL;
38364 2 : if ( 0 < sizeOfActualPool )
38365 : {
38366 0 : storageArraySgOmpNotinbranchClause = new SgOmpNotinbranchClauseStorageClass[sizeOfActualPool] ;
38367 0 : inFile.read ( (char*) (storageArraySgOmpNotinbranchClause) , sizeof ( SgOmpNotinbranchClauseStorageClass ) * sizeOfActualPool) ;
38368 0 : SgOmpNotinbranchClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38369 : SgOmpNotinbranchClauseStorageClass* storageArray = storageArraySgOmpNotinbranchClause;
38370 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38371 : {
38372 0 : SgOmpNotinbranchClause* tmp = new SgOmpNotinbranchClause ( *storageArray ) ;
38373 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38374 0 : storageArray++ ;
38375 : }
38376 : }
38377 0 : delete [] storageArraySgOmpNotinbranchClause;
38378 2 : SgOmpNotinbranchClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38379 :
38380 :
38381 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpDependClause );
38382 2 : SgOmpDependClauseStorageClass* storageArraySgOmpDependClause = NULL;
38383 2 : if ( 0 < sizeOfActualPool )
38384 : {
38385 0 : storageArraySgOmpDependClause = new SgOmpDependClauseStorageClass[sizeOfActualPool] ;
38386 0 : inFile.read ( (char*) (storageArraySgOmpDependClause) , sizeof ( SgOmpDependClauseStorageClass ) * sizeOfActualPool) ;
38387 0 : SgOmpDependClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38388 : SgOmpDependClauseStorageClass* storageArray = storageArraySgOmpDependClause;
38389 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38390 : {
38391 0 : SgOmpDependClause* tmp = new SgOmpDependClause ( *storageArray ) ;
38392 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38393 0 : storageArray++ ;
38394 : }
38395 : }
38396 0 : delete [] storageArraySgOmpDependClause;
38397 2 : SgOmpDependClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38398 :
38399 :
38400 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpAffinityClause );
38401 2 : SgOmpAffinityClauseStorageClass* storageArraySgOmpAffinityClause = NULL;
38402 2 : if ( 0 < sizeOfActualPool )
38403 : {
38404 0 : storageArraySgOmpAffinityClause = new SgOmpAffinityClauseStorageClass[sizeOfActualPool] ;
38405 0 : inFile.read ( (char*) (storageArraySgOmpAffinityClause) , sizeof ( SgOmpAffinityClauseStorageClass ) * sizeOfActualPool) ;
38406 0 : SgOmpAffinityClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38407 : SgOmpAffinityClauseStorageClass* storageArray = storageArraySgOmpAffinityClause;
38408 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38409 : {
38410 0 : SgOmpAffinityClause* tmp = new SgOmpAffinityClause ( *storageArray ) ;
38411 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38412 0 : storageArray++ ;
38413 : }
38414 : }
38415 0 : delete [] storageArraySgOmpAffinityClause;
38416 2 : SgOmpAffinityClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38417 :
38418 :
38419 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpWhenClause );
38420 2 : SgOmpWhenClauseStorageClass* storageArraySgOmpWhenClause = NULL;
38421 2 : if ( 0 < sizeOfActualPool )
38422 : {
38423 0 : storageArraySgOmpWhenClause = new SgOmpWhenClauseStorageClass[sizeOfActualPool] ;
38424 0 : inFile.read ( (char*) (storageArraySgOmpWhenClause) , sizeof ( SgOmpWhenClauseStorageClass ) * sizeOfActualPool) ;
38425 0 : SgOmpWhenClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38426 : SgOmpWhenClauseStorageClass* storageArray = storageArraySgOmpWhenClause;
38427 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38428 : {
38429 0 : SgOmpWhenClause* tmp = new SgOmpWhenClause ( *storageArray ) ;
38430 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38431 0 : storageArray++ ;
38432 : }
38433 : }
38434 0 : delete [] storageArraySgOmpWhenClause;
38435 2 : SgOmpWhenClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38436 :
38437 :
38438 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpFullClause );
38439 2 : SgOmpFullClauseStorageClass* storageArraySgOmpFullClause = NULL;
38440 2 : if ( 0 < sizeOfActualPool )
38441 : {
38442 0 : storageArraySgOmpFullClause = new SgOmpFullClauseStorageClass[sizeOfActualPool] ;
38443 0 : inFile.read ( (char*) (storageArraySgOmpFullClause) , sizeof ( SgOmpFullClauseStorageClass ) * sizeOfActualPool) ;
38444 0 : SgOmpFullClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38445 : SgOmpFullClauseStorageClass* storageArray = storageArraySgOmpFullClause;
38446 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38447 : {
38448 0 : SgOmpFullClause* tmp = new SgOmpFullClause ( *storageArray ) ;
38449 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38450 0 : storageArray++ ;
38451 : }
38452 : }
38453 0 : delete [] storageArraySgOmpFullClause;
38454 2 : SgOmpFullClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38455 :
38456 :
38457 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpPartialClause );
38458 2 : SgOmpPartialClauseStorageClass* storageArraySgOmpPartialClause = NULL;
38459 2 : if ( 0 < sizeOfActualPool )
38460 : {
38461 0 : storageArraySgOmpPartialClause = new SgOmpPartialClauseStorageClass[sizeOfActualPool] ;
38462 0 : inFile.read ( (char*) (storageArraySgOmpPartialClause) , sizeof ( SgOmpPartialClauseStorageClass ) * sizeOfActualPool) ;
38463 0 : SgOmpPartialClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38464 : SgOmpPartialClauseStorageClass* storageArray = storageArraySgOmpPartialClause;
38465 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38466 : {
38467 0 : SgOmpPartialClause* tmp = new SgOmpPartialClause ( *storageArray ) ;
38468 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38469 0 : storageArray++ ;
38470 : }
38471 : }
38472 0 : delete [] storageArraySgOmpPartialClause;
38473 2 : SgOmpPartialClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38474 :
38475 :
38476 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOmpSizesClause );
38477 2 : SgOmpSizesClauseStorageClass* storageArraySgOmpSizesClause = NULL;
38478 2 : if ( 0 < sizeOfActualPool )
38479 : {
38480 0 : storageArraySgOmpSizesClause = new SgOmpSizesClauseStorageClass[sizeOfActualPool] ;
38481 0 : inFile.read ( (char*) (storageArraySgOmpSizesClause) , sizeof ( SgOmpSizesClauseStorageClass ) * sizeOfActualPool) ;
38482 0 : SgOmpSizesClauseStorageClass :: readEasyStorageDataFromFile(inFile) ;
38483 : SgOmpSizesClauseStorageClass* storageArray = storageArraySgOmpSizesClause;
38484 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38485 : {
38486 0 : SgOmpSizesClause* tmp = new SgOmpSizesClause ( *storageArray ) ;
38487 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38488 0 : storageArray++ ;
38489 : }
38490 : }
38491 0 : delete [] storageArraySgOmpSizesClause;
38492 2 : SgOmpSizesClauseStorageClass :: deleteStaticDataOfEasyStorageClasses();
38493 :
38494 :
38495 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirBranchField );
38496 2 : SgUpirBranchFieldStorageClass* storageArraySgUpirBranchField = NULL;
38497 2 : if ( 0 < sizeOfActualPool )
38498 : {
38499 0 : storageArraySgUpirBranchField = new SgUpirBranchFieldStorageClass[sizeOfActualPool] ;
38500 0 : inFile.read ( (char*) (storageArraySgUpirBranchField) , sizeof ( SgUpirBranchFieldStorageClass ) * sizeOfActualPool) ;
38501 0 : SgUpirBranchFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38502 : SgUpirBranchFieldStorageClass* storageArray = storageArraySgUpirBranchField;
38503 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38504 : {
38505 0 : SgUpirBranchField* tmp = new SgUpirBranchField ( *storageArray ) ;
38506 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38507 0 : storageArray++ ;
38508 : }
38509 : }
38510 0 : delete [] storageArraySgUpirBranchField;
38511 2 : SgUpirBranchFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38512 :
38513 :
38514 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirNestedLevelField );
38515 2 : SgUpirNestedLevelFieldStorageClass* storageArraySgUpirNestedLevelField = NULL;
38516 2 : if ( 0 < sizeOfActualPool )
38517 : {
38518 0 : storageArraySgUpirNestedLevelField = new SgUpirNestedLevelFieldStorageClass[sizeOfActualPool] ;
38519 0 : inFile.read ( (char*) (storageArraySgUpirNestedLevelField) , sizeof ( SgUpirNestedLevelFieldStorageClass ) * sizeOfActualPool) ;
38520 0 : SgUpirNestedLevelFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38521 : SgUpirNestedLevelFieldStorageClass* storageArray = storageArraySgUpirNestedLevelField;
38522 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38523 : {
38524 0 : SgUpirNestedLevelField* tmp = new SgUpirNestedLevelField ( *storageArray ) ;
38525 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38526 0 : storageArray++ ;
38527 : }
38528 : }
38529 0 : delete [] storageArraySgUpirNestedLevelField;
38530 2 : SgUpirNestedLevelFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38531 :
38532 :
38533 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirNestedParentField );
38534 2 : SgUpirNestedParentFieldStorageClass* storageArraySgUpirNestedParentField = NULL;
38535 2 : if ( 0 < sizeOfActualPool )
38536 : {
38537 0 : storageArraySgUpirNestedParentField = new SgUpirNestedParentFieldStorageClass[sizeOfActualPool] ;
38538 0 : inFile.read ( (char*) (storageArraySgUpirNestedParentField) , sizeof ( SgUpirNestedParentFieldStorageClass ) * sizeOfActualPool) ;
38539 0 : SgUpirNestedParentFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38540 : SgUpirNestedParentFieldStorageClass* storageArray = storageArraySgUpirNestedParentField;
38541 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38542 : {
38543 0 : SgUpirNestedParentField* tmp = new SgUpirNestedParentField ( *storageArray ) ;
38544 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38545 0 : storageArray++ ;
38546 : }
38547 : }
38548 0 : delete [] storageArraySgUpirNestedParentField;
38549 2 : SgUpirNestedParentFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38550 :
38551 :
38552 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirNestedChildField );
38553 2 : SgUpirNestedChildFieldStorageClass* storageArraySgUpirNestedChildField = NULL;
38554 2 : if ( 0 < sizeOfActualPool )
38555 : {
38556 0 : storageArraySgUpirNestedChildField = new SgUpirNestedChildFieldStorageClass[sizeOfActualPool] ;
38557 0 : inFile.read ( (char*) (storageArraySgUpirNestedChildField) , sizeof ( SgUpirNestedChildFieldStorageClass ) * sizeOfActualPool) ;
38558 0 : SgUpirNestedChildFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38559 : SgUpirNestedChildFieldStorageClass* storageArray = storageArraySgUpirNestedChildField;
38560 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38561 : {
38562 0 : SgUpirNestedChildField* tmp = new SgUpirNestedChildField ( *storageArray ) ;
38563 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38564 0 : storageArray++ ;
38565 : }
38566 : }
38567 0 : delete [] storageArraySgUpirNestedChildField;
38568 2 : SgUpirNestedChildFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38569 :
38570 :
38571 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirSyncField );
38572 2 : SgUpirSyncFieldStorageClass* storageArraySgUpirSyncField = NULL;
38573 2 : if ( 0 < sizeOfActualPool )
38574 : {
38575 0 : storageArraySgUpirSyncField = new SgUpirSyncFieldStorageClass[sizeOfActualPool] ;
38576 0 : inFile.read ( (char*) (storageArraySgUpirSyncField) , sizeof ( SgUpirSyncFieldStorageClass ) * sizeOfActualPool) ;
38577 0 : SgUpirSyncFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38578 : SgUpirSyncFieldStorageClass* storageArray = storageArraySgUpirSyncField;
38579 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38580 : {
38581 0 : SgUpirSyncField* tmp = new SgUpirSyncField ( *storageArray ) ;
38582 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38583 0 : storageArray++ ;
38584 : }
38585 : }
38586 0 : delete [] storageArraySgUpirSyncField;
38587 2 : SgUpirSyncFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38588 :
38589 :
38590 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirDataField );
38591 2 : SgUpirDataFieldStorageClass* storageArraySgUpirDataField = NULL;
38592 2 : if ( 0 < sizeOfActualPool )
38593 : {
38594 0 : storageArraySgUpirDataField = new SgUpirDataFieldStorageClass[sizeOfActualPool] ;
38595 0 : inFile.read ( (char*) (storageArraySgUpirDataField) , sizeof ( SgUpirDataFieldStorageClass ) * sizeOfActualPool) ;
38596 0 : SgUpirDataFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38597 : SgUpirDataFieldStorageClass* storageArray = storageArraySgUpirDataField;
38598 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38599 : {
38600 0 : SgUpirDataField* tmp = new SgUpirDataField ( *storageArray ) ;
38601 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38602 0 : storageArray++ ;
38603 : }
38604 : }
38605 0 : delete [] storageArraySgUpirDataField;
38606 2 : SgUpirDataFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38607 :
38608 :
38609 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirDataItemField );
38610 2 : SgUpirDataItemFieldStorageClass* storageArraySgUpirDataItemField = NULL;
38611 2 : if ( 0 < sizeOfActualPool )
38612 : {
38613 0 : storageArraySgUpirDataItemField = new SgUpirDataItemFieldStorageClass[sizeOfActualPool] ;
38614 0 : inFile.read ( (char*) (storageArraySgUpirDataItemField) , sizeof ( SgUpirDataItemFieldStorageClass ) * sizeOfActualPool) ;
38615 0 : SgUpirDataItemFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38616 : SgUpirDataItemFieldStorageClass* storageArray = storageArraySgUpirDataItemField;
38617 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38618 : {
38619 0 : SgUpirDataItemField* tmp = new SgUpirDataItemField ( *storageArray ) ;
38620 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38621 0 : storageArray++ ;
38622 : }
38623 : }
38624 0 : delete [] storageArraySgUpirDataItemField;
38625 2 : SgUpirDataItemFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38626 :
38627 :
38628 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpirTargetField );
38629 2 : SgUpirTargetFieldStorageClass* storageArraySgUpirTargetField = NULL;
38630 2 : if ( 0 < sizeOfActualPool )
38631 : {
38632 0 : storageArraySgUpirTargetField = new SgUpirTargetFieldStorageClass[sizeOfActualPool] ;
38633 0 : inFile.read ( (char*) (storageArraySgUpirTargetField) , sizeof ( SgUpirTargetFieldStorageClass ) * sizeOfActualPool) ;
38634 0 : SgUpirTargetFieldStorageClass :: readEasyStorageDataFromFile(inFile) ;
38635 : SgUpirTargetFieldStorageClass* storageArray = storageArraySgUpirTargetField;
38636 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38637 : {
38638 0 : SgUpirTargetField* tmp = new SgUpirTargetField ( *storageArray ) ;
38639 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38640 0 : storageArray++ ;
38641 : }
38642 : }
38643 0 : delete [] storageArraySgUpirTargetField;
38644 2 : SgUpirTargetFieldStorageClass :: deleteStaticDataOfEasyStorageClasses();
38645 :
38646 :
38647 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOpenclAccessModeModifier );
38648 2 : SgOpenclAccessModeModifierStorageClass* storageArraySgOpenclAccessModeModifier = NULL;
38649 2 : if ( 0 < sizeOfActualPool )
38650 : {
38651 0 : storageArraySgOpenclAccessModeModifier = new SgOpenclAccessModeModifierStorageClass[sizeOfActualPool] ;
38652 0 : inFile.read ( (char*) (storageArraySgOpenclAccessModeModifier) , sizeof ( SgOpenclAccessModeModifierStorageClass ) * sizeOfActualPool) ;
38653 : SgOpenclAccessModeModifierStorageClass* storageArray = storageArraySgOpenclAccessModeModifier;
38654 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38655 : {
38656 0 : SgOpenclAccessModeModifier* tmp = new SgOpenclAccessModeModifier ( *storageArray ) ;
38657 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38658 0 : storageArray++ ;
38659 : }
38660 : }
38661 0 : delete [] storageArraySgOpenclAccessModeModifier;
38662 :
38663 :
38664 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOpenStatement );
38665 2 : SgOpenStatementStorageClass* storageArraySgOpenStatement = NULL;
38666 2 : if ( 0 < sizeOfActualPool )
38667 : {
38668 0 : storageArraySgOpenStatement = new SgOpenStatementStorageClass[sizeOfActualPool] ;
38669 0 : inFile.read ( (char*) (storageArraySgOpenStatement) , sizeof ( SgOpenStatementStorageClass ) * sizeOfActualPool) ;
38670 0 : SgOpenStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
38671 : SgOpenStatementStorageClass* storageArray = storageArraySgOpenStatement;
38672 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38673 : {
38674 0 : SgOpenStatement* tmp = new SgOpenStatement ( *storageArray ) ;
38675 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38676 0 : storageArray++ ;
38677 : }
38678 : }
38679 0 : delete [] storageArraySgOpenStatement;
38680 2 : SgOpenStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
38681 :
38682 :
38683 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOptions );
38684 2 : SgOptionsStorageClass* storageArraySgOptions = NULL;
38685 2 : if ( 0 < sizeOfActualPool )
38686 : {
38687 0 : storageArraySgOptions = new SgOptionsStorageClass[sizeOfActualPool] ;
38688 0 : inFile.read ( (char*) (storageArraySgOptions) , sizeof ( SgOptionsStorageClass ) * sizeOfActualPool) ;
38689 : SgOptionsStorageClass* storageArray = storageArraySgOptions;
38690 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38691 : {
38692 0 : SgOptions* tmp = new SgOptions ( *storageArray ) ;
38693 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38694 0 : storageArray++ ;
38695 : }
38696 : }
38697 0 : delete [] storageArraySgOptions;
38698 :
38699 :
38700 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgOrOp );
38701 2 : SgOrOpStorageClass* storageArraySgOrOp = NULL;
38702 2 : if ( 0 < sizeOfActualPool )
38703 : {
38704 84 : storageArraySgOrOp = new SgOrOpStorageClass[sizeOfActualPool] ;
38705 1 : inFile.read ( (char*) (storageArraySgOrOp) , sizeof ( SgOrOpStorageClass ) * sizeOfActualPool) ;
38706 1 : SgOrOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38707 : SgOrOpStorageClass* storageArray = storageArraySgOrOp;
38708 84 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38709 : {
38710 83 : SgOrOp* tmp = new SgOrOp ( *storageArray ) ;
38711 83 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38712 83 : storageArray++ ;
38713 : }
38714 : }
38715 1 : delete [] storageArraySgOrOp;
38716 2 : SgOrOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38717 :
38718 :
38719 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgParameterStatement );
38720 2 : SgParameterStatementStorageClass* storageArraySgParameterStatement = NULL;
38721 2 : if ( 0 < sizeOfActualPool )
38722 : {
38723 0 : storageArraySgParameterStatement = new SgParameterStatementStorageClass[sizeOfActualPool] ;
38724 0 : inFile.read ( (char*) (storageArraySgParameterStatement) , sizeof ( SgParameterStatementStorageClass ) * sizeOfActualPool) ;
38725 0 : SgParameterStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
38726 : SgParameterStatementStorageClass* storageArray = storageArraySgParameterStatement;
38727 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38728 : {
38729 0 : SgParameterStatement* tmp = new SgParameterStatement ( *storageArray ) ;
38730 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38731 0 : storageArray++ ;
38732 : }
38733 : }
38734 0 : delete [] storageArraySgParameterStatement;
38735 2 : SgParameterStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
38736 :
38737 :
38738 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPartialFunctionModifierType );
38739 2 : SgPartialFunctionModifierTypeStorageClass* storageArraySgPartialFunctionModifierType = NULL;
38740 2 : if ( 0 < sizeOfActualPool )
38741 : {
38742 0 : storageArraySgPartialFunctionModifierType = new SgPartialFunctionModifierTypeStorageClass[sizeOfActualPool] ;
38743 0 : inFile.read ( (char*) (storageArraySgPartialFunctionModifierType) , sizeof ( SgPartialFunctionModifierTypeStorageClass ) * sizeOfActualPool) ;
38744 0 : SgPartialFunctionModifierTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
38745 : SgPartialFunctionModifierTypeStorageClass* storageArray = storageArraySgPartialFunctionModifierType;
38746 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38747 : {
38748 0 : SgPartialFunctionModifierType* tmp = new SgPartialFunctionModifierType ( *storageArray ) ;
38749 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38750 0 : storageArray++ ;
38751 : }
38752 : }
38753 0 : delete [] storageArraySgPartialFunctionModifierType;
38754 2 : SgPartialFunctionModifierTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
38755 :
38756 :
38757 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPartialFunctionType );
38758 2 : SgPartialFunctionTypeStorageClass* storageArraySgPartialFunctionType = NULL;
38759 2 : if ( 0 < sizeOfActualPool )
38760 : {
38761 0 : storageArraySgPartialFunctionType = new SgPartialFunctionTypeStorageClass[sizeOfActualPool] ;
38762 0 : inFile.read ( (char*) (storageArraySgPartialFunctionType) , sizeof ( SgPartialFunctionTypeStorageClass ) * sizeOfActualPool) ;
38763 0 : SgPartialFunctionTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
38764 : SgPartialFunctionTypeStorageClass* storageArray = storageArraySgPartialFunctionType;
38765 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38766 : {
38767 0 : SgPartialFunctionType* tmp = new SgPartialFunctionType ( *storageArray ) ;
38768 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38769 0 : storageArray++ ;
38770 : }
38771 : }
38772 0 : delete [] storageArraySgPartialFunctionType;
38773 2 : SgPartialFunctionTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
38774 :
38775 :
38776 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPassStatement );
38777 2 : SgPassStatementStorageClass* storageArraySgPassStatement = NULL;
38778 2 : if ( 0 < sizeOfActualPool )
38779 : {
38780 0 : storageArraySgPassStatement = new SgPassStatementStorageClass[sizeOfActualPool] ;
38781 0 : inFile.read ( (char*) (storageArraySgPassStatement) , sizeof ( SgPassStatementStorageClass ) * sizeOfActualPool) ;
38782 0 : SgPassStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
38783 : SgPassStatementStorageClass* storageArray = storageArraySgPassStatement;
38784 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38785 : {
38786 0 : SgPassStatement* tmp = new SgPassStatement ( *storageArray ) ;
38787 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38788 0 : storageArray++ ;
38789 : }
38790 : }
38791 0 : delete [] storageArraySgPassStatement;
38792 2 : SgPassStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
38793 :
38794 :
38795 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPlusAssignOp );
38796 2 : SgPlusAssignOpStorageClass* storageArraySgPlusAssignOp = NULL;
38797 2 : if ( 0 < sizeOfActualPool )
38798 : {
38799 30 : storageArraySgPlusAssignOp = new SgPlusAssignOpStorageClass[sizeOfActualPool] ;
38800 1 : inFile.read ( (char*) (storageArraySgPlusAssignOp) , sizeof ( SgPlusAssignOpStorageClass ) * sizeOfActualPool) ;
38801 1 : SgPlusAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38802 : SgPlusAssignOpStorageClass* storageArray = storageArraySgPlusAssignOp;
38803 30 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38804 : {
38805 29 : SgPlusAssignOp* tmp = new SgPlusAssignOp ( *storageArray ) ;
38806 29 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38807 29 : storageArray++ ;
38808 : }
38809 : }
38810 1 : delete [] storageArraySgPlusAssignOp;
38811 2 : SgPlusAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38812 :
38813 :
38814 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPlusPlusOp );
38815 2 : SgPlusPlusOpStorageClass* storageArraySgPlusPlusOp = NULL;
38816 2 : if ( 0 < sizeOfActualPool )
38817 : {
38818 132 : storageArraySgPlusPlusOp = new SgPlusPlusOpStorageClass[sizeOfActualPool] ;
38819 1 : inFile.read ( (char*) (storageArraySgPlusPlusOp) , sizeof ( SgPlusPlusOpStorageClass ) * sizeOfActualPool) ;
38820 1 : SgPlusPlusOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38821 : SgPlusPlusOpStorageClass* storageArray = storageArraySgPlusPlusOp;
38822 132 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38823 : {
38824 131 : SgPlusPlusOp* tmp = new SgPlusPlusOp ( *storageArray ) ;
38825 131 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38826 131 : storageArray++ ;
38827 : }
38828 : }
38829 1 : delete [] storageArraySgPlusPlusOp;
38830 2 : SgPlusPlusOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38831 :
38832 :
38833 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPntrArrRefExp );
38834 2 : SgPntrArrRefExpStorageClass* storageArraySgPntrArrRefExp = NULL;
38835 2 : if ( 0 < sizeOfActualPool )
38836 : {
38837 127 : storageArraySgPntrArrRefExp = new SgPntrArrRefExpStorageClass[sizeOfActualPool] ;
38838 1 : inFile.read ( (char*) (storageArraySgPntrArrRefExp) , sizeof ( SgPntrArrRefExpStorageClass ) * sizeOfActualPool) ;
38839 1 : SgPntrArrRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38840 : SgPntrArrRefExpStorageClass* storageArray = storageArraySgPntrArrRefExp;
38841 127 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38842 : {
38843 126 : SgPntrArrRefExp* tmp = new SgPntrArrRefExp ( *storageArray ) ;
38844 126 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38845 126 : storageArray++ ;
38846 : }
38847 : }
38848 1 : delete [] storageArraySgPntrArrRefExp;
38849 2 : SgPntrArrRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38850 :
38851 :
38852 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPointerAssignOp );
38853 2 : SgPointerAssignOpStorageClass* storageArraySgPointerAssignOp = NULL;
38854 2 : if ( 0 < sizeOfActualPool )
38855 : {
38856 0 : storageArraySgPointerAssignOp = new SgPointerAssignOpStorageClass[sizeOfActualPool] ;
38857 0 : inFile.read ( (char*) (storageArraySgPointerAssignOp) , sizeof ( SgPointerAssignOpStorageClass ) * sizeOfActualPool) ;
38858 0 : SgPointerAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38859 : SgPointerAssignOpStorageClass* storageArray = storageArraySgPointerAssignOp;
38860 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38861 : {
38862 0 : SgPointerAssignOp* tmp = new SgPointerAssignOp ( *storageArray ) ;
38863 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38864 0 : storageArray++ ;
38865 : }
38866 : }
38867 0 : delete [] storageArraySgPointerAssignOp;
38868 2 : SgPointerAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38869 :
38870 :
38871 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPointerDerefExp );
38872 2 : SgPointerDerefExpStorageClass* storageArraySgPointerDerefExp = NULL;
38873 2 : if ( 0 < sizeOfActualPool )
38874 : {
38875 385 : storageArraySgPointerDerefExp = new SgPointerDerefExpStorageClass[sizeOfActualPool] ;
38876 1 : inFile.read ( (char*) (storageArraySgPointerDerefExp) , sizeof ( SgPointerDerefExpStorageClass ) * sizeOfActualPool) ;
38877 1 : SgPointerDerefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38878 : SgPointerDerefExpStorageClass* storageArray = storageArraySgPointerDerefExp;
38879 385 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38880 : {
38881 384 : SgPointerDerefExp* tmp = new SgPointerDerefExp ( *storageArray ) ;
38882 384 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38883 384 : storageArray++ ;
38884 : }
38885 : }
38886 1 : delete [] storageArraySgPointerDerefExp;
38887 2 : SgPointerDerefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38888 :
38889 :
38890 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPointerMemberType );
38891 2 : SgPointerMemberTypeStorageClass* storageArraySgPointerMemberType = NULL;
38892 2 : if ( 0 < sizeOfActualPool )
38893 : {
38894 30 : storageArraySgPointerMemberType = new SgPointerMemberTypeStorageClass[sizeOfActualPool] ;
38895 1 : inFile.read ( (char*) (storageArraySgPointerMemberType) , sizeof ( SgPointerMemberTypeStorageClass ) * sizeOfActualPool) ;
38896 1 : SgPointerMemberTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
38897 : SgPointerMemberTypeStorageClass* storageArray = storageArraySgPointerMemberType;
38898 30 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38899 : {
38900 29 : SgPointerMemberType* tmp = new SgPointerMemberType ( *storageArray ) ;
38901 29 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38902 29 : storageArray++ ;
38903 : }
38904 : }
38905 1 : delete [] storageArraySgPointerMemberType;
38906 2 : SgPointerMemberTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
38907 :
38908 :
38909 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPointerType );
38910 2 : SgPointerTypeStorageClass* storageArraySgPointerType = NULL;
38911 2 : if ( 0 < sizeOfActualPool )
38912 : {
38913 628 : storageArraySgPointerType = new SgPointerTypeStorageClass[sizeOfActualPool] ;
38914 2 : inFile.read ( (char*) (storageArraySgPointerType) , sizeof ( SgPointerTypeStorageClass ) * sizeOfActualPool) ;
38915 2 : SgPointerTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
38916 : SgPointerTypeStorageClass* storageArray = storageArraySgPointerType;
38917 628 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38918 : {
38919 626 : SgPointerType* tmp = new SgPointerType ( *storageArray ) ;
38920 626 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38921 626 : storageArray++ ;
38922 : }
38923 : }
38924 2 : delete [] storageArraySgPointerType;
38925 2 : SgPointerTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
38926 :
38927 :
38928 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPowerOp );
38929 2 : SgPowerOpStorageClass* storageArraySgPowerOp = NULL;
38930 2 : if ( 0 < sizeOfActualPool )
38931 : {
38932 0 : storageArraySgPowerOp = new SgPowerOpStorageClass[sizeOfActualPool] ;
38933 0 : inFile.read ( (char*) (storageArraySgPowerOp) , sizeof ( SgPowerOpStorageClass ) * sizeOfActualPool) ;
38934 0 : SgPowerOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
38935 : SgPowerOpStorageClass* storageArray = storageArraySgPowerOp;
38936 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38937 : {
38938 0 : SgPowerOp* tmp = new SgPowerOp ( *storageArray ) ;
38939 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38940 0 : storageArray++ ;
38941 : }
38942 : }
38943 0 : delete [] storageArraySgPowerOp;
38944 2 : SgPowerOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
38945 :
38946 :
38947 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPragma );
38948 2 : SgPragmaStorageClass* storageArraySgPragma = NULL;
38949 2 : if ( 0 < sizeOfActualPool )
38950 : {
38951 98 : storageArraySgPragma = new SgPragmaStorageClass[sizeOfActualPool] ;
38952 1 : inFile.read ( (char*) (storageArraySgPragma) , sizeof ( SgPragmaStorageClass ) * sizeOfActualPool) ;
38953 1 : SgPragmaStorageClass :: readEasyStorageDataFromFile(inFile) ;
38954 : SgPragmaStorageClass* storageArray = storageArraySgPragma;
38955 98 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38956 : {
38957 97 : SgPragma* tmp = new SgPragma ( *storageArray ) ;
38958 97 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38959 97 : storageArray++ ;
38960 : }
38961 : }
38962 1 : delete [] storageArraySgPragma;
38963 2 : SgPragmaStorageClass :: deleteStaticDataOfEasyStorageClasses();
38964 :
38965 :
38966 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPragmaDeclaration );
38967 2 : SgPragmaDeclarationStorageClass* storageArraySgPragmaDeclaration = NULL;
38968 2 : if ( 0 < sizeOfActualPool )
38969 : {
38970 98 : storageArraySgPragmaDeclaration = new SgPragmaDeclarationStorageClass[sizeOfActualPool] ;
38971 1 : inFile.read ( (char*) (storageArraySgPragmaDeclaration) , sizeof ( SgPragmaDeclarationStorageClass ) * sizeOfActualPool) ;
38972 1 : SgPragmaDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
38973 : SgPragmaDeclarationStorageClass* storageArray = storageArraySgPragmaDeclaration;
38974 98 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38975 : {
38976 97 : SgPragmaDeclaration* tmp = new SgPragmaDeclaration ( *storageArray ) ;
38977 97 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38978 97 : storageArray++ ;
38979 : }
38980 : }
38981 1 : delete [] storageArraySgPragmaDeclaration;
38982 2 : SgPragmaDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
38983 :
38984 :
38985 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPrintStatement );
38986 2 : SgPrintStatementStorageClass* storageArraySgPrintStatement = NULL;
38987 2 : if ( 0 < sizeOfActualPool )
38988 : {
38989 0 : storageArraySgPrintStatement = new SgPrintStatementStorageClass[sizeOfActualPool] ;
38990 0 : inFile.read ( (char*) (storageArraySgPrintStatement) , sizeof ( SgPrintStatementStorageClass ) * sizeOfActualPool) ;
38991 0 : SgPrintStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
38992 : SgPrintStatementStorageClass* storageArray = storageArraySgPrintStatement;
38993 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
38994 : {
38995 0 : SgPrintStatement* tmp = new SgPrintStatement ( *storageArray ) ;
38996 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
38997 0 : storageArray++ ;
38998 : }
38999 : }
39000 0 : delete [] storageArraySgPrintStatement;
39001 2 : SgPrintStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39002 :
39003 :
39004 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgProcedureHeaderStatement );
39005 2 : SgProcedureHeaderStatementStorageClass* storageArraySgProcedureHeaderStatement = NULL;
39006 2 : if ( 0 < sizeOfActualPool )
39007 : {
39008 0 : storageArraySgProcedureHeaderStatement = new SgProcedureHeaderStatementStorageClass[sizeOfActualPool] ;
39009 0 : inFile.read ( (char*) (storageArraySgProcedureHeaderStatement) , sizeof ( SgProcedureHeaderStatementStorageClass ) * sizeOfActualPool) ;
39010 0 : SgProcedureHeaderStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39011 : SgProcedureHeaderStatementStorageClass* storageArray = storageArraySgProcedureHeaderStatement;
39012 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39013 : {
39014 0 : SgProcedureHeaderStatement* tmp = new SgProcedureHeaderStatement ( *storageArray ) ;
39015 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39016 0 : storageArray++ ;
39017 : }
39018 : }
39019 0 : delete [] storageArraySgProcedureHeaderStatement;
39020 2 : SgProcedureHeaderStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39021 :
39022 :
39023 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgProgramHeaderStatement );
39024 2 : SgProgramHeaderStatementStorageClass* storageArraySgProgramHeaderStatement = NULL;
39025 2 : if ( 0 < sizeOfActualPool )
39026 : {
39027 0 : storageArraySgProgramHeaderStatement = new SgProgramHeaderStatementStorageClass[sizeOfActualPool] ;
39028 0 : inFile.read ( (char*) (storageArraySgProgramHeaderStatement) , sizeof ( SgProgramHeaderStatementStorageClass ) * sizeOfActualPool) ;
39029 0 : SgProgramHeaderStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39030 : SgProgramHeaderStatementStorageClass* storageArray = storageArraySgProgramHeaderStatement;
39031 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39032 : {
39033 0 : SgProgramHeaderStatement* tmp = new SgProgramHeaderStatement ( *storageArray ) ;
39034 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39035 0 : storageArray++ ;
39036 : }
39037 : }
39038 0 : delete [] storageArraySgProgramHeaderStatement;
39039 2 : SgProgramHeaderStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39040 :
39041 :
39042 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgProject );
39043 2 : SgProjectStorageClass* storageArraySgProject = NULL;
39044 2 : if ( 0 < sizeOfActualPool )
39045 : {
39046 4 : storageArraySgProject = new SgProjectStorageClass[sizeOfActualPool] ;
39047 2 : inFile.read ( (char*) (storageArraySgProject) , sizeof ( SgProjectStorageClass ) * sizeOfActualPool) ;
39048 2 : SgProjectStorageClass :: readEasyStorageDataFromFile(inFile) ;
39049 : SgProjectStorageClass* storageArray = storageArraySgProject;
39050 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39051 : {
39052 2 : SgProject* tmp = new SgProject ( *storageArray ) ;
39053 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39054 2 : storageArray++ ;
39055 : }
39056 : }
39057 2 : delete [] storageArraySgProject;
39058 2 : SgProjectStorageClass :: deleteStaticDataOfEasyStorageClasses();
39059 :
39060 :
39061 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgPseudoDestructorRefExp );
39062 2 : SgPseudoDestructorRefExpStorageClass* storageArraySgPseudoDestructorRefExp = NULL;
39063 2 : if ( 0 < sizeOfActualPool )
39064 : {
39065 0 : storageArraySgPseudoDestructorRefExp = new SgPseudoDestructorRefExpStorageClass[sizeOfActualPool] ;
39066 0 : inFile.read ( (char*) (storageArraySgPseudoDestructorRefExp) , sizeof ( SgPseudoDestructorRefExpStorageClass ) * sizeOfActualPool) ;
39067 0 : SgPseudoDestructorRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39068 : SgPseudoDestructorRefExpStorageClass* storageArray = storageArraySgPseudoDestructorRefExp;
39069 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39070 : {
39071 0 : SgPseudoDestructorRefExp* tmp = new SgPseudoDestructorRefExp ( *storageArray ) ;
39072 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39073 0 : storageArray++ ;
39074 : }
39075 : }
39076 0 : delete [] storageArraySgPseudoDestructorRefExp;
39077 2 : SgPseudoDestructorRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39078 :
39079 :
39080 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgQualifiedName );
39081 2 : SgQualifiedNameStorageClass* storageArraySgQualifiedName = NULL;
39082 2 : if ( 0 < sizeOfActualPool )
39083 : {
39084 0 : storageArraySgQualifiedName = new SgQualifiedNameStorageClass[sizeOfActualPool] ;
39085 0 : inFile.read ( (char*) (storageArraySgQualifiedName) , sizeof ( SgQualifiedNameStorageClass ) * sizeOfActualPool) ;
39086 : SgQualifiedNameStorageClass* storageArray = storageArraySgQualifiedName;
39087 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39088 : {
39089 0 : SgQualifiedName* tmp = new SgQualifiedName ( *storageArray ) ;
39090 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39091 0 : storageArray++ ;
39092 : }
39093 : }
39094 0 : delete [] storageArraySgQualifiedName;
39095 :
39096 :
39097 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgQualifiedNameType );
39098 2 : SgQualifiedNameTypeStorageClass* storageArraySgQualifiedNameType = NULL;
39099 2 : if ( 0 < sizeOfActualPool )
39100 : {
39101 0 : storageArraySgQualifiedNameType = new SgQualifiedNameTypeStorageClass[sizeOfActualPool] ;
39102 0 : inFile.read ( (char*) (storageArraySgQualifiedNameType) , sizeof ( SgQualifiedNameTypeStorageClass ) * sizeOfActualPool) ;
39103 0 : SgQualifiedNameTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
39104 : SgQualifiedNameTypeStorageClass* storageArray = storageArraySgQualifiedNameType;
39105 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39106 : {
39107 0 : SgQualifiedNameType* tmp = new SgQualifiedNameType ( *storageArray ) ;
39108 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39109 0 : storageArray++ ;
39110 : }
39111 : }
39112 0 : delete [] storageArraySgQualifiedNameType;
39113 2 : SgQualifiedNameTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
39114 :
39115 :
39116 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRangeExp );
39117 2 : SgRangeExpStorageClass* storageArraySgRangeExp = NULL;
39118 2 : if ( 0 < sizeOfActualPool )
39119 : {
39120 0 : storageArraySgRangeExp = new SgRangeExpStorageClass[sizeOfActualPool] ;
39121 0 : inFile.read ( (char*) (storageArraySgRangeExp) , sizeof ( SgRangeExpStorageClass ) * sizeOfActualPool) ;
39122 0 : SgRangeExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39123 : SgRangeExpStorageClass* storageArray = storageArraySgRangeExp;
39124 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39125 : {
39126 0 : SgRangeExp* tmp = new SgRangeExp ( *storageArray ) ;
39127 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39128 0 : storageArray++ ;
39129 : }
39130 : }
39131 0 : delete [] storageArraySgRangeExp;
39132 2 : SgRangeExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39133 :
39134 :
39135 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRangeBasedForStatement );
39136 2 : SgRangeBasedForStatementStorageClass* storageArraySgRangeBasedForStatement = NULL;
39137 2 : if ( 0 < sizeOfActualPool )
39138 : {
39139 0 : storageArraySgRangeBasedForStatement = new SgRangeBasedForStatementStorageClass[sizeOfActualPool] ;
39140 0 : inFile.read ( (char*) (storageArraySgRangeBasedForStatement) , sizeof ( SgRangeBasedForStatementStorageClass ) * sizeOfActualPool) ;
39141 0 : SgRangeBasedForStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39142 : SgRangeBasedForStatementStorageClass* storageArray = storageArraySgRangeBasedForStatement;
39143 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39144 : {
39145 0 : SgRangeBasedForStatement* tmp = new SgRangeBasedForStatement ( *storageArray ) ;
39146 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39147 0 : storageArray++ ;
39148 : }
39149 : }
39150 0 : delete [] storageArraySgRangeBasedForStatement;
39151 2 : SgRangeBasedForStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39152 :
39153 :
39154 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgReadStatement );
39155 2 : SgReadStatementStorageClass* storageArraySgReadStatement = NULL;
39156 2 : if ( 0 < sizeOfActualPool )
39157 : {
39158 0 : storageArraySgReadStatement = new SgReadStatementStorageClass[sizeOfActualPool] ;
39159 0 : inFile.read ( (char*) (storageArraySgReadStatement) , sizeof ( SgReadStatementStorageClass ) * sizeOfActualPool) ;
39160 0 : SgReadStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39161 : SgReadStatementStorageClass* storageArray = storageArraySgReadStatement;
39162 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39163 : {
39164 0 : SgReadStatement* tmp = new SgReadStatement ( *storageArray ) ;
39165 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39166 0 : storageArray++ ;
39167 : }
39168 : }
39169 0 : delete [] storageArraySgReadStatement;
39170 2 : SgReadStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39171 :
39172 :
39173 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRealPartOp );
39174 2 : SgRealPartOpStorageClass* storageArraySgRealPartOp = NULL;
39175 2 : if ( 0 < sizeOfActualPool )
39176 : {
39177 0 : storageArraySgRealPartOp = new SgRealPartOpStorageClass[sizeOfActualPool] ;
39178 0 : inFile.read ( (char*) (storageArraySgRealPartOp) , sizeof ( SgRealPartOpStorageClass ) * sizeOfActualPool) ;
39179 0 : SgRealPartOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39180 : SgRealPartOpStorageClass* storageArray = storageArraySgRealPartOp;
39181 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39182 : {
39183 0 : SgRealPartOp* tmp = new SgRealPartOp ( *storageArray ) ;
39184 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39185 0 : storageArray++ ;
39186 : }
39187 : }
39188 0 : delete [] storageArraySgRealPartOp;
39189 2 : SgRealPartOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39190 :
39191 :
39192 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRefExp );
39193 2 : SgRefExpStorageClass* storageArraySgRefExp = NULL;
39194 2 : if ( 0 < sizeOfActualPool )
39195 : {
39196 0 : storageArraySgRefExp = new SgRefExpStorageClass[sizeOfActualPool] ;
39197 0 : inFile.read ( (char*) (storageArraySgRefExp) , sizeof ( SgRefExpStorageClass ) * sizeOfActualPool) ;
39198 0 : SgRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39199 : SgRefExpStorageClass* storageArray = storageArraySgRefExp;
39200 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39201 : {
39202 0 : SgRefExp* tmp = new SgRefExp ( *storageArray ) ;
39203 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39204 0 : storageArray++ ;
39205 : }
39206 : }
39207 0 : delete [] storageArraySgRefExp;
39208 2 : SgRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39209 :
39210 :
39211 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgReferenceType );
39212 2 : SgReferenceTypeStorageClass* storageArraySgReferenceType = NULL;
39213 2 : if ( 0 < sizeOfActualPool )
39214 : {
39215 725 : storageArraySgReferenceType = new SgReferenceTypeStorageClass[sizeOfActualPool] ;
39216 1 : inFile.read ( (char*) (storageArraySgReferenceType) , sizeof ( SgReferenceTypeStorageClass ) * sizeOfActualPool) ;
39217 1 : SgReferenceTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
39218 : SgReferenceTypeStorageClass* storageArray = storageArraySgReferenceType;
39219 725 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39220 : {
39221 724 : SgReferenceType* tmp = new SgReferenceType ( *storageArray ) ;
39222 724 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39223 724 : storageArray++ ;
39224 : }
39225 : }
39226 1 : delete [] storageArraySgReferenceType;
39227 2 : SgReferenceTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
39228 :
39229 :
39230 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRenamePair );
39231 2 : SgRenamePairStorageClass* storageArraySgRenamePair = NULL;
39232 2 : if ( 0 < sizeOfActualPool )
39233 : {
39234 0 : storageArraySgRenamePair = new SgRenamePairStorageClass[sizeOfActualPool] ;
39235 0 : inFile.read ( (char*) (storageArraySgRenamePair) , sizeof ( SgRenamePairStorageClass ) * sizeOfActualPool) ;
39236 0 : SgRenamePairStorageClass :: readEasyStorageDataFromFile(inFile) ;
39237 : SgRenamePairStorageClass* storageArray = storageArraySgRenamePair;
39238 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39239 : {
39240 0 : SgRenamePair* tmp = new SgRenamePair ( *storageArray ) ;
39241 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39242 0 : storageArray++ ;
39243 : }
39244 : }
39245 0 : delete [] storageArraySgRenamePair;
39246 2 : SgRenamePairStorageClass :: deleteStaticDataOfEasyStorageClasses();
39247 :
39248 :
39249 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRenameSymbol );
39250 2 : SgRenameSymbolStorageClass* storageArraySgRenameSymbol = NULL;
39251 2 : if ( 0 < sizeOfActualPool )
39252 : {
39253 0 : storageArraySgRenameSymbol = new SgRenameSymbolStorageClass[sizeOfActualPool] ;
39254 0 : inFile.read ( (char*) (storageArraySgRenameSymbol) , sizeof ( SgRenameSymbolStorageClass ) * sizeOfActualPool) ;
39255 0 : SgRenameSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
39256 : SgRenameSymbolStorageClass* storageArray = storageArraySgRenameSymbol;
39257 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39258 : {
39259 0 : SgRenameSymbol* tmp = new SgRenameSymbol ( *storageArray ) ;
39260 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39261 0 : storageArray++ ;
39262 : }
39263 : }
39264 0 : delete [] storageArraySgRenameSymbol;
39265 2 : SgRenameSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
39266 :
39267 :
39268 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgReturnStmt );
39269 2 : SgReturnStmtStorageClass* storageArraySgReturnStmt = NULL;
39270 2 : if ( 0 < sizeOfActualPool )
39271 : {
39272 1407 : storageArraySgReturnStmt = new SgReturnStmtStorageClass[sizeOfActualPool] ;
39273 2 : inFile.read ( (char*) (storageArraySgReturnStmt) , sizeof ( SgReturnStmtStorageClass ) * sizeOfActualPool) ;
39274 2 : SgReturnStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
39275 : SgReturnStmtStorageClass* storageArray = storageArraySgReturnStmt;
39276 1407 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39277 : {
39278 1405 : SgReturnStmt* tmp = new SgReturnStmt ( *storageArray ) ;
39279 1405 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39280 1405 : storageArray++ ;
39281 : }
39282 : }
39283 2 : delete [] storageArraySgReturnStmt;
39284 2 : SgReturnStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
39285 :
39286 :
39287 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRewindStatement );
39288 2 : SgRewindStatementStorageClass* storageArraySgRewindStatement = NULL;
39289 2 : if ( 0 < sizeOfActualPool )
39290 : {
39291 0 : storageArraySgRewindStatement = new SgRewindStatementStorageClass[sizeOfActualPool] ;
39292 0 : inFile.read ( (char*) (storageArraySgRewindStatement) , sizeof ( SgRewindStatementStorageClass ) * sizeOfActualPool) ;
39293 0 : SgRewindStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39294 : SgRewindStatementStorageClass* storageArray = storageArraySgRewindStatement;
39295 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39296 : {
39297 0 : SgRewindStatement* tmp = new SgRewindStatement ( *storageArray ) ;
39298 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39299 0 : storageArray++ ;
39300 : }
39301 : }
39302 0 : delete [] storageArraySgRewindStatement;
39303 2 : SgRewindStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39304 :
39305 :
39306 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRshiftAssignOp );
39307 2 : SgRshiftAssignOpStorageClass* storageArraySgRshiftAssignOp = NULL;
39308 2 : if ( 0 < sizeOfActualPool )
39309 : {
39310 3 : storageArraySgRshiftAssignOp = new SgRshiftAssignOpStorageClass[sizeOfActualPool] ;
39311 1 : inFile.read ( (char*) (storageArraySgRshiftAssignOp) , sizeof ( SgRshiftAssignOpStorageClass ) * sizeOfActualPool) ;
39312 1 : SgRshiftAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39313 : SgRshiftAssignOpStorageClass* storageArray = storageArraySgRshiftAssignOp;
39314 3 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39315 : {
39316 2 : SgRshiftAssignOp* tmp = new SgRshiftAssignOp ( *storageArray ) ;
39317 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39318 2 : storageArray++ ;
39319 : }
39320 : }
39321 1 : delete [] storageArraySgRshiftAssignOp;
39322 2 : SgRshiftAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39323 :
39324 :
39325 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRshiftOp );
39326 2 : SgRshiftOpStorageClass* storageArraySgRshiftOp = NULL;
39327 2 : if ( 0 < sizeOfActualPool )
39328 : {
39329 9 : storageArraySgRshiftOp = new SgRshiftOpStorageClass[sizeOfActualPool] ;
39330 1 : inFile.read ( (char*) (storageArraySgRshiftOp) , sizeof ( SgRshiftOpStorageClass ) * sizeOfActualPool) ;
39331 1 : SgRshiftOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39332 : SgRshiftOpStorageClass* storageArray = storageArraySgRshiftOp;
39333 9 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39334 : {
39335 8 : SgRshiftOp* tmp = new SgRshiftOp ( *storageArray ) ;
39336 8 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39337 8 : storageArray++ ;
39338 : }
39339 : }
39340 1 : delete [] storageArraySgRshiftOp;
39341 2 : SgRshiftOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39342 :
39343 :
39344 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgRvalueReferenceType );
39345 2 : SgRvalueReferenceTypeStorageClass* storageArraySgRvalueReferenceType = NULL;
39346 2 : if ( 0 < sizeOfActualPool )
39347 : {
39348 183 : storageArraySgRvalueReferenceType = new SgRvalueReferenceTypeStorageClass[sizeOfActualPool] ;
39349 1 : inFile.read ( (char*) (storageArraySgRvalueReferenceType) , sizeof ( SgRvalueReferenceTypeStorageClass ) * sizeOfActualPool) ;
39350 1 : SgRvalueReferenceTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
39351 : SgRvalueReferenceTypeStorageClass* storageArray = storageArraySgRvalueReferenceType;
39352 183 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39353 : {
39354 182 : SgRvalueReferenceType* tmp = new SgRvalueReferenceType ( *storageArray ) ;
39355 182 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39356 182 : storageArray++ ;
39357 : }
39358 : }
39359 1 : delete [] storageArraySgRvalueReferenceType;
39360 2 : SgRvalueReferenceTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
39361 :
39362 :
39363 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgScopeOp );
39364 2 : SgScopeOpStorageClass* storageArraySgScopeOp = NULL;
39365 2 : if ( 0 < sizeOfActualPool )
39366 : {
39367 0 : storageArraySgScopeOp = new SgScopeOpStorageClass[sizeOfActualPool] ;
39368 0 : inFile.read ( (char*) (storageArraySgScopeOp) , sizeof ( SgScopeOpStorageClass ) * sizeOfActualPool) ;
39369 0 : SgScopeOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39370 : SgScopeOpStorageClass* storageArray = storageArraySgScopeOp;
39371 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39372 : {
39373 0 : SgScopeOp* tmp = new SgScopeOp ( *storageArray ) ;
39374 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39375 0 : storageArray++ ;
39376 : }
39377 : }
39378 0 : delete [] storageArraySgScopeOp;
39379 2 : SgScopeOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39380 :
39381 :
39382 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgScopeStatement );
39383 2 : SgScopeStatementStorageClass* storageArraySgScopeStatement = NULL;
39384 2 : if ( 0 < sizeOfActualPool )
39385 : {
39386 0 : storageArraySgScopeStatement = new SgScopeStatementStorageClass[sizeOfActualPool] ;
39387 0 : inFile.read ( (char*) (storageArraySgScopeStatement) , sizeof ( SgScopeStatementStorageClass ) * sizeOfActualPool) ;
39388 0 : SgScopeStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39389 : SgScopeStatementStorageClass* storageArray = storageArraySgScopeStatement;
39390 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39391 : {
39392 0 : SgScopeStatement* tmp = new SgScopeStatement ( *storageArray ) ;
39393 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39394 0 : storageArray++ ;
39395 : }
39396 : }
39397 0 : delete [] storageArraySgScopeStatement;
39398 2 : SgScopeStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39399 :
39400 :
39401 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSequenceStatement );
39402 2 : SgSequenceStatementStorageClass* storageArraySgSequenceStatement = NULL;
39403 2 : if ( 0 < sizeOfActualPool )
39404 : {
39405 0 : storageArraySgSequenceStatement = new SgSequenceStatementStorageClass[sizeOfActualPool] ;
39406 0 : inFile.read ( (char*) (storageArraySgSequenceStatement) , sizeof ( SgSequenceStatementStorageClass ) * sizeOfActualPool) ;
39407 0 : SgSequenceStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39408 : SgSequenceStatementStorageClass* storageArray = storageArraySgSequenceStatement;
39409 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39410 : {
39411 0 : SgSequenceStatement* tmp = new SgSequenceStatement ( *storageArray ) ;
39412 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39413 0 : storageArray++ ;
39414 : }
39415 : }
39416 0 : delete [] storageArraySgSequenceStatement;
39417 2 : SgSequenceStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39418 :
39419 :
39420 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSetComprehension );
39421 2 : SgSetComprehensionStorageClass* storageArraySgSetComprehension = NULL;
39422 2 : if ( 0 < sizeOfActualPool )
39423 : {
39424 0 : storageArraySgSetComprehension = new SgSetComprehensionStorageClass[sizeOfActualPool] ;
39425 0 : inFile.read ( (char*) (storageArraySgSetComprehension) , sizeof ( SgSetComprehensionStorageClass ) * sizeOfActualPool) ;
39426 0 : SgSetComprehensionStorageClass :: readEasyStorageDataFromFile(inFile) ;
39427 : SgSetComprehensionStorageClass* storageArray = storageArraySgSetComprehension;
39428 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39429 : {
39430 0 : SgSetComprehension* tmp = new SgSetComprehension ( *storageArray ) ;
39431 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39432 0 : storageArray++ ;
39433 : }
39434 : }
39435 0 : delete [] storageArraySgSetComprehension;
39436 2 : SgSetComprehensionStorageClass :: deleteStaticDataOfEasyStorageClasses();
39437 :
39438 :
39439 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgShortVal );
39440 2 : SgShortValStorageClass* storageArraySgShortVal = NULL;
39441 2 : if ( 0 < sizeOfActualPool )
39442 : {
39443 0 : storageArraySgShortVal = new SgShortValStorageClass[sizeOfActualPool] ;
39444 0 : inFile.read ( (char*) (storageArraySgShortVal) , sizeof ( SgShortValStorageClass ) * sizeOfActualPool) ;
39445 0 : SgShortValStorageClass :: readEasyStorageDataFromFile(inFile) ;
39446 : SgShortValStorageClass* storageArray = storageArraySgShortVal;
39447 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39448 : {
39449 0 : SgShortVal* tmp = new SgShortVal ( *storageArray ) ;
39450 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39451 0 : storageArray++ ;
39452 : }
39453 : }
39454 0 : delete [] storageArraySgShortVal;
39455 2 : SgShortValStorageClass :: deleteStaticDataOfEasyStorageClasses();
39456 :
39457 :
39458 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDBinaryOp );
39459 2 : SgSIMDBinaryOpStorageClass* storageArraySgSIMDBinaryOp = NULL;
39460 2 : if ( 0 < sizeOfActualPool )
39461 : {
39462 0 : storageArraySgSIMDBinaryOp = new SgSIMDBinaryOpStorageClass[sizeOfActualPool] ;
39463 0 : inFile.read ( (char*) (storageArraySgSIMDBinaryOp) , sizeof ( SgSIMDBinaryOpStorageClass ) * sizeOfActualPool) ;
39464 0 : SgSIMDBinaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39465 : SgSIMDBinaryOpStorageClass* storageArray = storageArraySgSIMDBinaryOp;
39466 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39467 : {
39468 0 : SgSIMDBinaryOp* tmp = new SgSIMDBinaryOp ( *storageArray ) ;
39469 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39470 0 : storageArray++ ;
39471 : }
39472 : }
39473 0 : delete [] storageArraySgSIMDBinaryOp;
39474 2 : SgSIMDBinaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39475 :
39476 :
39477 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDAddOp );
39478 2 : SgSIMDAddOpStorageClass* storageArraySgSIMDAddOp = NULL;
39479 2 : if ( 0 < sizeOfActualPool )
39480 : {
39481 0 : storageArraySgSIMDAddOp = new SgSIMDAddOpStorageClass[sizeOfActualPool] ;
39482 0 : inFile.read ( (char*) (storageArraySgSIMDAddOp) , sizeof ( SgSIMDAddOpStorageClass ) * sizeOfActualPool) ;
39483 0 : SgSIMDAddOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39484 : SgSIMDAddOpStorageClass* storageArray = storageArraySgSIMDAddOp;
39485 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39486 : {
39487 0 : SgSIMDAddOp* tmp = new SgSIMDAddOp ( *storageArray ) ;
39488 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39489 0 : storageArray++ ;
39490 : }
39491 : }
39492 0 : delete [] storageArraySgSIMDAddOp;
39493 2 : SgSIMDAddOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39494 :
39495 :
39496 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDSubOp );
39497 2 : SgSIMDSubOpStorageClass* storageArraySgSIMDSubOp = NULL;
39498 2 : if ( 0 < sizeOfActualPool )
39499 : {
39500 0 : storageArraySgSIMDSubOp = new SgSIMDSubOpStorageClass[sizeOfActualPool] ;
39501 0 : inFile.read ( (char*) (storageArraySgSIMDSubOp) , sizeof ( SgSIMDSubOpStorageClass ) * sizeOfActualPool) ;
39502 0 : SgSIMDSubOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39503 : SgSIMDSubOpStorageClass* storageArray = storageArraySgSIMDSubOp;
39504 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39505 : {
39506 0 : SgSIMDSubOp* tmp = new SgSIMDSubOp ( *storageArray ) ;
39507 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39508 0 : storageArray++ ;
39509 : }
39510 : }
39511 0 : delete [] storageArraySgSIMDSubOp;
39512 2 : SgSIMDSubOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39513 :
39514 :
39515 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDMulOp );
39516 2 : SgSIMDMulOpStorageClass* storageArraySgSIMDMulOp = NULL;
39517 2 : if ( 0 < sizeOfActualPool )
39518 : {
39519 0 : storageArraySgSIMDMulOp = new SgSIMDMulOpStorageClass[sizeOfActualPool] ;
39520 0 : inFile.read ( (char*) (storageArraySgSIMDMulOp) , sizeof ( SgSIMDMulOpStorageClass ) * sizeOfActualPool) ;
39521 0 : SgSIMDMulOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39522 : SgSIMDMulOpStorageClass* storageArray = storageArraySgSIMDMulOp;
39523 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39524 : {
39525 0 : SgSIMDMulOp* tmp = new SgSIMDMulOp ( *storageArray ) ;
39526 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39527 0 : storageArray++ ;
39528 : }
39529 : }
39530 0 : delete [] storageArraySgSIMDMulOp;
39531 2 : SgSIMDMulOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39532 :
39533 :
39534 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDDivOp );
39535 2 : SgSIMDDivOpStorageClass* storageArraySgSIMDDivOp = NULL;
39536 2 : if ( 0 < sizeOfActualPool )
39537 : {
39538 0 : storageArraySgSIMDDivOp = new SgSIMDDivOpStorageClass[sizeOfActualPool] ;
39539 0 : inFile.read ( (char*) (storageArraySgSIMDDivOp) , sizeof ( SgSIMDDivOpStorageClass ) * sizeOfActualPool) ;
39540 0 : SgSIMDDivOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39541 : SgSIMDDivOpStorageClass* storageArray = storageArraySgSIMDDivOp;
39542 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39543 : {
39544 0 : SgSIMDDivOp* tmp = new SgSIMDDivOp ( *storageArray ) ;
39545 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39546 0 : storageArray++ ;
39547 : }
39548 : }
39549 0 : delete [] storageArraySgSIMDDivOp;
39550 2 : SgSIMDDivOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39551 :
39552 :
39553 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDFmaOp );
39554 2 : SgSIMDFmaOpStorageClass* storageArraySgSIMDFmaOp = NULL;
39555 2 : if ( 0 < sizeOfActualPool )
39556 : {
39557 0 : storageArraySgSIMDFmaOp = new SgSIMDFmaOpStorageClass[sizeOfActualPool] ;
39558 0 : inFile.read ( (char*) (storageArraySgSIMDFmaOp) , sizeof ( SgSIMDFmaOpStorageClass ) * sizeOfActualPool) ;
39559 0 : SgSIMDFmaOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39560 : SgSIMDFmaOpStorageClass* storageArray = storageArraySgSIMDFmaOp;
39561 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39562 : {
39563 0 : SgSIMDFmaOp* tmp = new SgSIMDFmaOp ( *storageArray ) ;
39564 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39565 0 : storageArray++ ;
39566 : }
39567 : }
39568 0 : delete [] storageArraySgSIMDFmaOp;
39569 2 : SgSIMDFmaOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39570 :
39571 :
39572 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDLoad );
39573 2 : SgSIMDLoadStorageClass* storageArraySgSIMDLoad = NULL;
39574 2 : if ( 0 < sizeOfActualPool )
39575 : {
39576 0 : storageArraySgSIMDLoad = new SgSIMDLoadStorageClass[sizeOfActualPool] ;
39577 0 : inFile.read ( (char*) (storageArraySgSIMDLoad) , sizeof ( SgSIMDLoadStorageClass ) * sizeOfActualPool) ;
39578 0 : SgSIMDLoadStorageClass :: readEasyStorageDataFromFile(inFile) ;
39579 : SgSIMDLoadStorageClass* storageArray = storageArraySgSIMDLoad;
39580 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39581 : {
39582 0 : SgSIMDLoad* tmp = new SgSIMDLoad ( *storageArray ) ;
39583 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39584 0 : storageArray++ ;
39585 : }
39586 : }
39587 0 : delete [] storageArraySgSIMDLoad;
39588 2 : SgSIMDLoadStorageClass :: deleteStaticDataOfEasyStorageClasses();
39589 :
39590 :
39591 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDBroadcast );
39592 2 : SgSIMDBroadcastStorageClass* storageArraySgSIMDBroadcast = NULL;
39593 2 : if ( 0 < sizeOfActualPool )
39594 : {
39595 0 : storageArraySgSIMDBroadcast = new SgSIMDBroadcastStorageClass[sizeOfActualPool] ;
39596 0 : inFile.read ( (char*) (storageArraySgSIMDBroadcast) , sizeof ( SgSIMDBroadcastStorageClass ) * sizeOfActualPool) ;
39597 0 : SgSIMDBroadcastStorageClass :: readEasyStorageDataFromFile(inFile) ;
39598 : SgSIMDBroadcastStorageClass* storageArray = storageArraySgSIMDBroadcast;
39599 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39600 : {
39601 0 : SgSIMDBroadcast* tmp = new SgSIMDBroadcast ( *storageArray ) ;
39602 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39603 0 : storageArray++ ;
39604 : }
39605 : }
39606 0 : delete [] storageArraySgSIMDBroadcast;
39607 2 : SgSIMDBroadcastStorageClass :: deleteStaticDataOfEasyStorageClasses();
39608 :
39609 :
39610 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDStore );
39611 2 : SgSIMDStoreStorageClass* storageArraySgSIMDStore = NULL;
39612 2 : if ( 0 < sizeOfActualPool )
39613 : {
39614 0 : storageArraySgSIMDStore = new SgSIMDStoreStorageClass[sizeOfActualPool] ;
39615 0 : inFile.read ( (char*) (storageArraySgSIMDStore) , sizeof ( SgSIMDStoreStorageClass ) * sizeOfActualPool) ;
39616 0 : SgSIMDStoreStorageClass :: readEasyStorageDataFromFile(inFile) ;
39617 : SgSIMDStoreStorageClass* storageArray = storageArraySgSIMDStore;
39618 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39619 : {
39620 0 : SgSIMDStore* tmp = new SgSIMDStore ( *storageArray ) ;
39621 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39622 0 : storageArray++ ;
39623 : }
39624 : }
39625 0 : delete [] storageArraySgSIMDStore;
39626 2 : SgSIMDStoreStorageClass :: deleteStaticDataOfEasyStorageClasses();
39627 :
39628 :
39629 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDPartialStore );
39630 2 : SgSIMDPartialStoreStorageClass* storageArraySgSIMDPartialStore = NULL;
39631 2 : if ( 0 < sizeOfActualPool )
39632 : {
39633 0 : storageArraySgSIMDPartialStore = new SgSIMDPartialStoreStorageClass[sizeOfActualPool] ;
39634 0 : inFile.read ( (char*) (storageArraySgSIMDPartialStore) , sizeof ( SgSIMDPartialStoreStorageClass ) * sizeOfActualPool) ;
39635 0 : SgSIMDPartialStoreStorageClass :: readEasyStorageDataFromFile(inFile) ;
39636 : SgSIMDPartialStoreStorageClass* storageArray = storageArraySgSIMDPartialStore;
39637 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39638 : {
39639 0 : SgSIMDPartialStore* tmp = new SgSIMDPartialStore ( *storageArray ) ;
39640 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39641 0 : storageArray++ ;
39642 : }
39643 : }
39644 0 : delete [] storageArraySgSIMDPartialStore;
39645 2 : SgSIMDPartialStoreStorageClass :: deleteStaticDataOfEasyStorageClasses();
39646 :
39647 :
39648 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDScalarStore );
39649 2 : SgSIMDScalarStoreStorageClass* storageArraySgSIMDScalarStore = NULL;
39650 2 : if ( 0 < sizeOfActualPool )
39651 : {
39652 0 : storageArraySgSIMDScalarStore = new SgSIMDScalarStoreStorageClass[sizeOfActualPool] ;
39653 0 : inFile.read ( (char*) (storageArraySgSIMDScalarStore) , sizeof ( SgSIMDScalarStoreStorageClass ) * sizeOfActualPool) ;
39654 0 : SgSIMDScalarStoreStorageClass :: readEasyStorageDataFromFile(inFile) ;
39655 : SgSIMDScalarStoreStorageClass* storageArray = storageArraySgSIMDScalarStore;
39656 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39657 : {
39658 0 : SgSIMDScalarStore* tmp = new SgSIMDScalarStore ( *storageArray ) ;
39659 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39660 0 : storageArray++ ;
39661 : }
39662 : }
39663 0 : delete [] storageArraySgSIMDScalarStore;
39664 2 : SgSIMDScalarStoreStorageClass :: deleteStaticDataOfEasyStorageClasses();
39665 :
39666 :
39667 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDGather );
39668 2 : SgSIMDGatherStorageClass* storageArraySgSIMDGather = NULL;
39669 2 : if ( 0 < sizeOfActualPool )
39670 : {
39671 0 : storageArraySgSIMDGather = new SgSIMDGatherStorageClass[sizeOfActualPool] ;
39672 0 : inFile.read ( (char*) (storageArraySgSIMDGather) , sizeof ( SgSIMDGatherStorageClass ) * sizeOfActualPool) ;
39673 0 : SgSIMDGatherStorageClass :: readEasyStorageDataFromFile(inFile) ;
39674 : SgSIMDGatherStorageClass* storageArray = storageArraySgSIMDGather;
39675 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39676 : {
39677 0 : SgSIMDGather* tmp = new SgSIMDGather ( *storageArray ) ;
39678 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39679 0 : storageArray++ ;
39680 : }
39681 : }
39682 0 : delete [] storageArraySgSIMDGather;
39683 2 : SgSIMDGatherStorageClass :: deleteStaticDataOfEasyStorageClasses();
39684 :
39685 :
39686 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDExplicitGather );
39687 2 : SgSIMDExplicitGatherStorageClass* storageArraySgSIMDExplicitGather = NULL;
39688 2 : if ( 0 < sizeOfActualPool )
39689 : {
39690 0 : storageArraySgSIMDExplicitGather = new SgSIMDExplicitGatherStorageClass[sizeOfActualPool] ;
39691 0 : inFile.read ( (char*) (storageArraySgSIMDExplicitGather) , sizeof ( SgSIMDExplicitGatherStorageClass ) * sizeOfActualPool) ;
39692 0 : SgSIMDExplicitGatherStorageClass :: readEasyStorageDataFromFile(inFile) ;
39693 : SgSIMDExplicitGatherStorageClass* storageArray = storageArraySgSIMDExplicitGather;
39694 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39695 : {
39696 0 : SgSIMDExplicitGather* tmp = new SgSIMDExplicitGather ( *storageArray ) ;
39697 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39698 0 : storageArray++ ;
39699 : }
39700 : }
39701 0 : delete [] storageArraySgSIMDExplicitGather;
39702 2 : SgSIMDExplicitGatherStorageClass :: deleteStaticDataOfEasyStorageClasses();
39703 :
39704 :
39705 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSIMDScatter );
39706 2 : SgSIMDScatterStorageClass* storageArraySgSIMDScatter = NULL;
39707 2 : if ( 0 < sizeOfActualPool )
39708 : {
39709 0 : storageArraySgSIMDScatter = new SgSIMDScatterStorageClass[sizeOfActualPool] ;
39710 0 : inFile.read ( (char*) (storageArraySgSIMDScatter) , sizeof ( SgSIMDScatterStorageClass ) * sizeOfActualPool) ;
39711 0 : SgSIMDScatterStorageClass :: readEasyStorageDataFromFile(inFile) ;
39712 : SgSIMDScatterStorageClass* storageArray = storageArraySgSIMDScatter;
39713 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39714 : {
39715 0 : SgSIMDScatter* tmp = new SgSIMDScatter ( *storageArray ) ;
39716 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39717 0 : storageArray++ ;
39718 : }
39719 : }
39720 0 : delete [] storageArraySgSIMDScatter;
39721 2 : SgSIMDScatterStorageClass :: deleteStaticDataOfEasyStorageClasses();
39722 :
39723 :
39724 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSizeOfOp );
39725 2 : SgSizeOfOpStorageClass* storageArraySgSizeOfOp = NULL;
39726 2 : if ( 0 < sizeOfActualPool )
39727 : {
39728 100 : storageArraySgSizeOfOp = new SgSizeOfOpStorageClass[sizeOfActualPool] ;
39729 2 : inFile.read ( (char*) (storageArraySgSizeOfOp) , sizeof ( SgSizeOfOpStorageClass ) * sizeOfActualPool) ;
39730 2 : SgSizeOfOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39731 : SgSizeOfOpStorageClass* storageArray = storageArraySgSizeOfOp;
39732 100 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39733 : {
39734 98 : SgSizeOfOp* tmp = new SgSizeOfOp ( *storageArray ) ;
39735 98 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39736 98 : storageArray++ ;
39737 : }
39738 : }
39739 2 : delete [] storageArraySgSizeOfOp;
39740 2 : SgSizeOfOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39741 :
39742 :
39743 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgAlignOfOp );
39744 2 : SgAlignOfOpStorageClass* storageArraySgAlignOfOp = NULL;
39745 2 : if ( 0 < sizeOfActualPool )
39746 : {
39747 6 : storageArraySgAlignOfOp = new SgAlignOfOpStorageClass[sizeOfActualPool] ;
39748 1 : inFile.read ( (char*) (storageArraySgAlignOfOp) , sizeof ( SgAlignOfOpStorageClass ) * sizeOfActualPool) ;
39749 1 : SgAlignOfOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39750 : SgAlignOfOpStorageClass* storageArray = storageArraySgAlignOfOp;
39751 6 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39752 : {
39753 5 : SgAlignOfOp* tmp = new SgAlignOfOp ( *storageArray ) ;
39754 5 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39755 5 : storageArray++ ;
39756 : }
39757 : }
39758 1 : delete [] storageArraySgAlignOfOp;
39759 2 : SgAlignOfOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39760 :
39761 :
39762 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSourceFile );
39763 2 : SgSourceFileStorageClass* storageArraySgSourceFile = NULL;
39764 2 : if ( 0 < sizeOfActualPool )
39765 : {
39766 199 : storageArraySgSourceFile = new SgSourceFileStorageClass[sizeOfActualPool] ;
39767 2 : inFile.read ( (char*) (storageArraySgSourceFile) , sizeof ( SgSourceFileStorageClass ) * sizeOfActualPool) ;
39768 2 : SgSourceFileStorageClass :: readEasyStorageDataFromFile(inFile) ;
39769 : SgSourceFileStorageClass* storageArray = storageArraySgSourceFile;
39770 199 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39771 : {
39772 197 : SgSourceFile* tmp = new SgSourceFile ( *storageArray ) ;
39773 197 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39774 197 : storageArray++ ;
39775 : }
39776 : }
39777 2 : delete [] storageArraySgSourceFile;
39778 2 : SgSourceFileStorageClass :: deleteStaticDataOfEasyStorageClasses();
39779 :
39780 :
39781 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSpaceshipOp );
39782 2 : SgSpaceshipOpStorageClass* storageArraySgSpaceshipOp = NULL;
39783 2 : if ( 0 < sizeOfActualPool )
39784 : {
39785 0 : storageArraySgSpaceshipOp = new SgSpaceshipOpStorageClass[sizeOfActualPool] ;
39786 0 : inFile.read ( (char*) (storageArraySgSpaceshipOp) , sizeof ( SgSpaceshipOpStorageClass ) * sizeOfActualPool) ;
39787 0 : SgSpaceshipOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
39788 : SgSpaceshipOpStorageClass* storageArray = storageArraySgSpaceshipOp;
39789 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39790 : {
39791 0 : SgSpaceshipOp* tmp = new SgSpaceshipOp ( *storageArray ) ;
39792 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39793 0 : storageArray++ ;
39794 : }
39795 : }
39796 0 : delete [] storageArraySgSpaceshipOp;
39797 2 : SgSpaceshipOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
39798 :
39799 :
39800 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSpawnStmt );
39801 2 : SgSpawnStmtStorageClass* storageArraySgSpawnStmt = NULL;
39802 2 : if ( 0 < sizeOfActualPool )
39803 : {
39804 0 : storageArraySgSpawnStmt = new SgSpawnStmtStorageClass[sizeOfActualPool] ;
39805 0 : inFile.read ( (char*) (storageArraySgSpawnStmt) , sizeof ( SgSpawnStmtStorageClass ) * sizeOfActualPool) ;
39806 0 : SgSpawnStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
39807 : SgSpawnStmtStorageClass* storageArray = storageArraySgSpawnStmt;
39808 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39809 : {
39810 0 : SgSpawnStmt* tmp = new SgSpawnStmt ( *storageArray ) ;
39811 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39812 0 : storageArray++ ;
39813 : }
39814 : }
39815 0 : delete [] storageArraySgSpawnStmt;
39816 2 : SgSpawnStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
39817 :
39818 :
39819 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSyncAllStatement );
39820 2 : SgSyncAllStatementStorageClass* storageArraySgSyncAllStatement = NULL;
39821 2 : if ( 0 < sizeOfActualPool )
39822 : {
39823 0 : storageArraySgSyncAllStatement = new SgSyncAllStatementStorageClass[sizeOfActualPool] ;
39824 0 : inFile.read ( (char*) (storageArraySgSyncAllStatement) , sizeof ( SgSyncAllStatementStorageClass ) * sizeOfActualPool) ;
39825 0 : SgSyncAllStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39826 : SgSyncAllStatementStorageClass* storageArray = storageArraySgSyncAllStatement;
39827 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39828 : {
39829 0 : SgSyncAllStatement* tmp = new SgSyncAllStatement ( *storageArray ) ;
39830 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39831 0 : storageArray++ ;
39832 : }
39833 : }
39834 0 : delete [] storageArraySgSyncAllStatement;
39835 2 : SgSyncAllStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39836 :
39837 :
39838 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSyncImagesStatement );
39839 2 : SgSyncImagesStatementStorageClass* storageArraySgSyncImagesStatement = NULL;
39840 2 : if ( 0 < sizeOfActualPool )
39841 : {
39842 0 : storageArraySgSyncImagesStatement = new SgSyncImagesStatementStorageClass[sizeOfActualPool] ;
39843 0 : inFile.read ( (char*) (storageArraySgSyncImagesStatement) , sizeof ( SgSyncImagesStatementStorageClass ) * sizeOfActualPool) ;
39844 0 : SgSyncImagesStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39845 : SgSyncImagesStatementStorageClass* storageArray = storageArraySgSyncImagesStatement;
39846 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39847 : {
39848 0 : SgSyncImagesStatement* tmp = new SgSyncImagesStatement ( *storageArray ) ;
39849 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39850 0 : storageArray++ ;
39851 : }
39852 : }
39853 0 : delete [] storageArraySgSyncImagesStatement;
39854 2 : SgSyncImagesStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39855 :
39856 :
39857 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSyncMemoryStatement );
39858 2 : SgSyncMemoryStatementStorageClass* storageArraySgSyncMemoryStatement = NULL;
39859 2 : if ( 0 < sizeOfActualPool )
39860 : {
39861 0 : storageArraySgSyncMemoryStatement = new SgSyncMemoryStatementStorageClass[sizeOfActualPool] ;
39862 0 : inFile.read ( (char*) (storageArraySgSyncMemoryStatement) , sizeof ( SgSyncMemoryStatementStorageClass ) * sizeOfActualPool) ;
39863 0 : SgSyncMemoryStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39864 : SgSyncMemoryStatementStorageClass* storageArray = storageArraySgSyncMemoryStatement;
39865 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39866 : {
39867 0 : SgSyncMemoryStatement* tmp = new SgSyncMemoryStatement ( *storageArray ) ;
39868 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39869 0 : storageArray++ ;
39870 : }
39871 : }
39872 0 : delete [] storageArraySgSyncMemoryStatement;
39873 2 : SgSyncMemoryStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39874 :
39875 :
39876 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSyncTeamStatement );
39877 2 : SgSyncTeamStatementStorageClass* storageArraySgSyncTeamStatement = NULL;
39878 2 : if ( 0 < sizeOfActualPool )
39879 : {
39880 0 : storageArraySgSyncTeamStatement = new SgSyncTeamStatementStorageClass[sizeOfActualPool] ;
39881 0 : inFile.read ( (char*) (storageArraySgSyncTeamStatement) , sizeof ( SgSyncTeamStatementStorageClass ) * sizeOfActualPool) ;
39882 0 : SgSyncTeamStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39883 : SgSyncTeamStatementStorageClass* storageArray = storageArraySgSyncTeamStatement;
39884 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39885 : {
39886 0 : SgSyncTeamStatement* tmp = new SgSyncTeamStatement ( *storageArray ) ;
39887 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39888 0 : storageArray++ ;
39889 : }
39890 : }
39891 0 : delete [] storageArraySgSyncTeamStatement;
39892 2 : SgSyncTeamStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39893 :
39894 :
39895 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgLockStatement );
39896 2 : SgLockStatementStorageClass* storageArraySgLockStatement = NULL;
39897 2 : if ( 0 < sizeOfActualPool )
39898 : {
39899 0 : storageArraySgLockStatement = new SgLockStatementStorageClass[sizeOfActualPool] ;
39900 0 : inFile.read ( (char*) (storageArraySgLockStatement) , sizeof ( SgLockStatementStorageClass ) * sizeOfActualPool) ;
39901 0 : SgLockStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39902 : SgLockStatementStorageClass* storageArray = storageArraySgLockStatement;
39903 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39904 : {
39905 0 : SgLockStatement* tmp = new SgLockStatement ( *storageArray ) ;
39906 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39907 0 : storageArray++ ;
39908 : }
39909 : }
39910 0 : delete [] storageArraySgLockStatement;
39911 2 : SgLockStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39912 :
39913 :
39914 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnlockStatement );
39915 2 : SgUnlockStatementStorageClass* storageArraySgUnlockStatement = NULL;
39916 2 : if ( 0 < sizeOfActualPool )
39917 : {
39918 0 : storageArraySgUnlockStatement = new SgUnlockStatementStorageClass[sizeOfActualPool] ;
39919 0 : inFile.read ( (char*) (storageArraySgUnlockStatement) , sizeof ( SgUnlockStatementStorageClass ) * sizeOfActualPool) ;
39920 0 : SgUnlockStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39921 : SgUnlockStatementStorageClass* storageArray = storageArraySgUnlockStatement;
39922 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39923 : {
39924 0 : SgUnlockStatement* tmp = new SgUnlockStatement ( *storageArray ) ;
39925 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39926 0 : storageArray++ ;
39927 : }
39928 : }
39929 0 : delete [] storageArraySgUnlockStatement;
39930 2 : SgUnlockStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39931 :
39932 :
39933 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgProcessControlStatement );
39934 2 : SgProcessControlStatementStorageClass* storageArraySgProcessControlStatement = NULL;
39935 2 : if ( 0 < sizeOfActualPool )
39936 : {
39937 0 : storageArraySgProcessControlStatement = new SgProcessControlStatementStorageClass[sizeOfActualPool] ;
39938 0 : inFile.read ( (char*) (storageArraySgProcessControlStatement) , sizeof ( SgProcessControlStatementStorageClass ) * sizeOfActualPool) ;
39939 0 : SgProcessControlStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39940 : SgProcessControlStatementStorageClass* storageArray = storageArraySgProcessControlStatement;
39941 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39942 : {
39943 0 : SgProcessControlStatement* tmp = new SgProcessControlStatement ( *storageArray ) ;
39944 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39945 0 : storageArray++ ;
39946 : }
39947 : }
39948 0 : delete [] storageArraySgProcessControlStatement;
39949 2 : SgProcessControlStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39950 :
39951 :
39952 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSpecialFunctionModifier );
39953 2 : SgSpecialFunctionModifierStorageClass* storageArraySgSpecialFunctionModifier = NULL;
39954 2 : if ( 0 < sizeOfActualPool )
39955 : {
39956 0 : storageArraySgSpecialFunctionModifier = new SgSpecialFunctionModifierStorageClass[sizeOfActualPool] ;
39957 0 : inFile.read ( (char*) (storageArraySgSpecialFunctionModifier) , sizeof ( SgSpecialFunctionModifierStorageClass ) * sizeOfActualPool) ;
39958 0 : SgSpecialFunctionModifierStorageClass :: readEasyStorageDataFromFile(inFile) ;
39959 : SgSpecialFunctionModifierStorageClass* storageArray = storageArraySgSpecialFunctionModifier;
39960 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39961 : {
39962 0 : SgSpecialFunctionModifier* tmp = new SgSpecialFunctionModifier ( *storageArray ) ;
39963 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39964 0 : storageArray++ ;
39965 : }
39966 : }
39967 0 : delete [] storageArraySgSpecialFunctionModifier;
39968 2 : SgSpecialFunctionModifierStorageClass :: deleteStaticDataOfEasyStorageClasses();
39969 :
39970 :
39971 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStatement );
39972 2 : SgStatementStorageClass* storageArraySgStatement = NULL;
39973 2 : if ( 0 < sizeOfActualPool )
39974 : {
39975 0 : storageArraySgStatement = new SgStatementStorageClass[sizeOfActualPool] ;
39976 0 : inFile.read ( (char*) (storageArraySgStatement) , sizeof ( SgStatementStorageClass ) * sizeOfActualPool) ;
39977 0 : SgStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
39978 : SgStatementStorageClass* storageArray = storageArraySgStatement;
39979 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39980 : {
39981 0 : SgStatement* tmp = new SgStatement ( *storageArray ) ;
39982 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
39983 0 : storageArray++ ;
39984 : }
39985 : }
39986 0 : delete [] storageArraySgStatement;
39987 2 : SgStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
39988 :
39989 :
39990 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStaticAssertionDeclaration );
39991 2 : SgStaticAssertionDeclarationStorageClass* storageArraySgStaticAssertionDeclaration = NULL;
39992 2 : if ( 0 < sizeOfActualPool )
39993 : {
39994 15 : storageArraySgStaticAssertionDeclaration = new SgStaticAssertionDeclarationStorageClass[sizeOfActualPool] ;
39995 1 : inFile.read ( (char*) (storageArraySgStaticAssertionDeclaration) , sizeof ( SgStaticAssertionDeclarationStorageClass ) * sizeOfActualPool) ;
39996 1 : SgStaticAssertionDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
39997 : SgStaticAssertionDeclarationStorageClass* storageArray = storageArraySgStaticAssertionDeclaration;
39998 15 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
39999 : {
40000 14 : SgStaticAssertionDeclaration* tmp = new SgStaticAssertionDeclaration ( *storageArray ) ;
40001 14 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40002 14 : storageArray++ ;
40003 : }
40004 : }
40005 1 : delete [] storageArraySgStaticAssertionDeclaration;
40006 2 : SgStaticAssertionDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40007 :
40008 :
40009 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStmtDeclarationStatement );
40010 2 : SgStmtDeclarationStatementStorageClass* storageArraySgStmtDeclarationStatement = NULL;
40011 2 : if ( 0 < sizeOfActualPool )
40012 : {
40013 0 : storageArraySgStmtDeclarationStatement = new SgStmtDeclarationStatementStorageClass[sizeOfActualPool] ;
40014 0 : inFile.read ( (char*) (storageArraySgStmtDeclarationStatement) , sizeof ( SgStmtDeclarationStatementStorageClass ) * sizeOfActualPool) ;
40015 0 : SgStmtDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
40016 : SgStmtDeclarationStatementStorageClass* storageArray = storageArraySgStmtDeclarationStatement;
40017 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40018 : {
40019 0 : SgStmtDeclarationStatement* tmp = new SgStmtDeclarationStatement ( *storageArray ) ;
40020 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40021 0 : storageArray++ ;
40022 : }
40023 : }
40024 0 : delete [] storageArraySgStmtDeclarationStatement;
40025 2 : SgStmtDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
40026 :
40027 :
40028 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStatementExpression );
40029 2 : SgStatementExpressionStorageClass* storageArraySgStatementExpression = NULL;
40030 2 : if ( 0 < sizeOfActualPool )
40031 : {
40032 0 : storageArraySgStatementExpression = new SgStatementExpressionStorageClass[sizeOfActualPool] ;
40033 0 : inFile.read ( (char*) (storageArraySgStatementExpression) , sizeof ( SgStatementExpressionStorageClass ) * sizeOfActualPool) ;
40034 0 : SgStatementExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
40035 : SgStatementExpressionStorageClass* storageArray = storageArraySgStatementExpression;
40036 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40037 : {
40038 0 : SgStatementExpression* tmp = new SgStatementExpression ( *storageArray ) ;
40039 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40040 0 : storageArray++ ;
40041 : }
40042 : }
40043 0 : delete [] storageArraySgStatementExpression;
40044 2 : SgStatementExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
40045 :
40046 :
40047 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStatementFunctionStatement );
40048 2 : SgStatementFunctionStatementStorageClass* storageArraySgStatementFunctionStatement = NULL;
40049 2 : if ( 0 < sizeOfActualPool )
40050 : {
40051 0 : storageArraySgStatementFunctionStatement = new SgStatementFunctionStatementStorageClass[sizeOfActualPool] ;
40052 0 : inFile.read ( (char*) (storageArraySgStatementFunctionStatement) , sizeof ( SgStatementFunctionStatementStorageClass ) * sizeOfActualPool) ;
40053 0 : SgStatementFunctionStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
40054 : SgStatementFunctionStatementStorageClass* storageArray = storageArraySgStatementFunctionStatement;
40055 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40056 : {
40057 0 : SgStatementFunctionStatement* tmp = new SgStatementFunctionStatement ( *storageArray ) ;
40058 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40059 0 : storageArray++ ;
40060 : }
40061 : }
40062 0 : delete [] storageArraySgStatementFunctionStatement;
40063 2 : SgStatementFunctionStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
40064 :
40065 :
40066 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStorageModifier );
40067 2 : SgStorageModifierStorageClass* storageArraySgStorageModifier = NULL;
40068 2 : if ( 0 < sizeOfActualPool )
40069 : {
40070 2 : storageArraySgStorageModifier = new SgStorageModifierStorageClass[sizeOfActualPool] ;
40071 2 : inFile.read ( (char*) (storageArraySgStorageModifier) , sizeof ( SgStorageModifierStorageClass ) * sizeOfActualPool) ;
40072 : SgStorageModifierStorageClass* storageArray = storageArraySgStorageModifier;
40073 55227 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40074 : {
40075 55225 : SgStorageModifier* tmp = new SgStorageModifier ( *storageArray ) ;
40076 55225 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40077 55225 : storageArray++ ;
40078 : }
40079 : }
40080 2 : delete [] storageArraySgStorageModifier;
40081 :
40082 :
40083 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStringConversion );
40084 2 : SgStringConversionStorageClass* storageArraySgStringConversion = NULL;
40085 2 : if ( 0 < sizeOfActualPool )
40086 : {
40087 0 : storageArraySgStringConversion = new SgStringConversionStorageClass[sizeOfActualPool] ;
40088 0 : inFile.read ( (char*) (storageArraySgStringConversion) , sizeof ( SgStringConversionStorageClass ) * sizeOfActualPool) ;
40089 0 : SgStringConversionStorageClass :: readEasyStorageDataFromFile(inFile) ;
40090 : SgStringConversionStorageClass* storageArray = storageArraySgStringConversion;
40091 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40092 : {
40093 0 : SgStringConversion* tmp = new SgStringConversion ( *storageArray ) ;
40094 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40095 0 : storageArray++ ;
40096 : }
40097 : }
40098 0 : delete [] storageArraySgStringConversion;
40099 2 : SgStringConversionStorageClass :: deleteStaticDataOfEasyStorageClasses();
40100 :
40101 :
40102 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStringKeyedBidirectionalGraph );
40103 2 : SgStringKeyedBidirectionalGraphStorageClass* storageArraySgStringKeyedBidirectionalGraph = NULL;
40104 2 : if ( 0 < sizeOfActualPool )
40105 : {
40106 0 : storageArraySgStringKeyedBidirectionalGraph = new SgStringKeyedBidirectionalGraphStorageClass[sizeOfActualPool] ;
40107 0 : inFile.read ( (char*) (storageArraySgStringKeyedBidirectionalGraph) , sizeof ( SgStringKeyedBidirectionalGraphStorageClass ) * sizeOfActualPool) ;
40108 0 : SgStringKeyedBidirectionalGraphStorageClass :: readEasyStorageDataFromFile(inFile) ;
40109 : SgStringKeyedBidirectionalGraphStorageClass* storageArray = storageArraySgStringKeyedBidirectionalGraph;
40110 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40111 : {
40112 0 : SgStringKeyedBidirectionalGraph* tmp = new SgStringKeyedBidirectionalGraph ( *storageArray ) ;
40113 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40114 0 : storageArray++ ;
40115 : }
40116 : }
40117 0 : delete [] storageArraySgStringKeyedBidirectionalGraph;
40118 2 : SgStringKeyedBidirectionalGraphStorageClass :: deleteStaticDataOfEasyStorageClasses();
40119 :
40120 :
40121 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStringVal );
40122 2 : SgStringValStorageClass* storageArraySgStringVal = NULL;
40123 2 : if ( 0 < sizeOfActualPool )
40124 : {
40125 84 : storageArraySgStringVal = new SgStringValStorageClass[sizeOfActualPool] ;
40126 2 : inFile.read ( (char*) (storageArraySgStringVal) , sizeof ( SgStringValStorageClass ) * sizeOfActualPool) ;
40127 2 : SgStringValStorageClass :: readEasyStorageDataFromFile(inFile) ;
40128 : SgStringValStorageClass* storageArray = storageArraySgStringVal;
40129 84 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40130 : {
40131 82 : SgStringVal* tmp = new SgStringVal ( *storageArray ) ;
40132 82 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40133 82 : storageArray++ ;
40134 : }
40135 : }
40136 2 : delete [] storageArraySgStringVal;
40137 2 : SgStringValStorageClass :: deleteStaticDataOfEasyStorageClasses();
40138 :
40139 :
40140 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgStructureModifier );
40141 2 : SgStructureModifierStorageClass* storageArraySgStructureModifier = NULL;
40142 2 : if ( 0 < sizeOfActualPool )
40143 : {
40144 0 : storageArraySgStructureModifier = new SgStructureModifierStorageClass[sizeOfActualPool] ;
40145 0 : inFile.read ( (char*) (storageArraySgStructureModifier) , sizeof ( SgStructureModifierStorageClass ) * sizeOfActualPool) ;
40146 : SgStructureModifierStorageClass* storageArray = storageArraySgStructureModifier;
40147 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40148 : {
40149 0 : SgStructureModifier* tmp = new SgStructureModifier ( *storageArray ) ;
40150 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40151 0 : storageArray++ ;
40152 : }
40153 : }
40154 0 : delete [] storageArraySgStructureModifier;
40155 :
40156 :
40157 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSubscriptExpression );
40158 2 : SgSubscriptExpressionStorageClass* storageArraySgSubscriptExpression = NULL;
40159 2 : if ( 0 < sizeOfActualPool )
40160 : {
40161 0 : storageArraySgSubscriptExpression = new SgSubscriptExpressionStorageClass[sizeOfActualPool] ;
40162 0 : inFile.read ( (char*) (storageArraySgSubscriptExpression) , sizeof ( SgSubscriptExpressionStorageClass ) * sizeOfActualPool) ;
40163 0 : SgSubscriptExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
40164 : SgSubscriptExpressionStorageClass* storageArray = storageArraySgSubscriptExpression;
40165 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40166 : {
40167 0 : SgSubscriptExpression* tmp = new SgSubscriptExpression ( *storageArray ) ;
40168 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40169 0 : storageArray++ ;
40170 : }
40171 : }
40172 0 : delete [] storageArraySgSubscriptExpression;
40173 2 : SgSubscriptExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
40174 :
40175 :
40176 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSubtractOp );
40177 2 : SgSubtractOpStorageClass* storageArraySgSubtractOp = NULL;
40178 2 : if ( 0 < sizeOfActualPool )
40179 : {
40180 213 : storageArraySgSubtractOp = new SgSubtractOpStorageClass[sizeOfActualPool] ;
40181 2 : inFile.read ( (char*) (storageArraySgSubtractOp) , sizeof ( SgSubtractOpStorageClass ) * sizeOfActualPool) ;
40182 2 : SgSubtractOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40183 : SgSubtractOpStorageClass* storageArray = storageArraySgSubtractOp;
40184 213 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40185 : {
40186 211 : SgSubtractOp* tmp = new SgSubtractOp ( *storageArray ) ;
40187 211 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40188 211 : storageArray++ ;
40189 : }
40190 : }
40191 2 : delete [] storageArraySgSubtractOp;
40192 2 : SgSubtractOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40193 :
40194 :
40195 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSupport );
40196 2 : SgSupportStorageClass* storageArraySgSupport = NULL;
40197 2 : if ( 0 < sizeOfActualPool )
40198 : {
40199 0 : storageArraySgSupport = new SgSupportStorageClass[sizeOfActualPool] ;
40200 0 : inFile.read ( (char*) (storageArraySgSupport) , sizeof ( SgSupportStorageClass ) * sizeOfActualPool) ;
40201 : SgSupportStorageClass* storageArray = storageArraySgSupport;
40202 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40203 : {
40204 0 : SgSupport* tmp = new SgSupport ( *storageArray ) ;
40205 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40206 0 : storageArray++ ;
40207 : }
40208 : }
40209 0 : delete [] storageArraySgSupport;
40210 :
40211 :
40212 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSwitchStatement );
40213 2 : SgSwitchStatementStorageClass* storageArraySgSwitchStatement = NULL;
40214 2 : if ( 0 < sizeOfActualPool )
40215 : {
40216 0 : storageArraySgSwitchStatement = new SgSwitchStatementStorageClass[sizeOfActualPool] ;
40217 0 : inFile.read ( (char*) (storageArraySgSwitchStatement) , sizeof ( SgSwitchStatementStorageClass ) * sizeOfActualPool) ;
40218 0 : SgSwitchStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
40219 : SgSwitchStatementStorageClass* storageArray = storageArraySgSwitchStatement;
40220 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40221 : {
40222 0 : SgSwitchStatement* tmp = new SgSwitchStatement ( *storageArray ) ;
40223 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40224 0 : storageArray++ ;
40225 : }
40226 : }
40227 0 : delete [] storageArraySgSwitchStatement;
40228 2 : SgSwitchStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
40229 :
40230 :
40231 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSymbolTable );
40232 2 : SgSymbolTableStorageClass* storageArraySgSymbolTable = NULL;
40233 2 : if ( 0 < sizeOfActualPool )
40234 : {
40235 26902 : storageArraySgSymbolTable = new SgSymbolTableStorageClass[sizeOfActualPool] ;
40236 2 : inFile.read ( (char*) (storageArraySgSymbolTable) , sizeof ( SgSymbolTableStorageClass ) * sizeOfActualPool) ;
40237 2 : SgSymbolTableStorageClass :: readEasyStorageDataFromFile(inFile) ;
40238 : SgSymbolTableStorageClass* storageArray = storageArraySgSymbolTable;
40239 26902 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40240 : {
40241 26900 : SgSymbolTable* tmp = new SgSymbolTable ( *storageArray ) ;
40242 26900 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40243 26900 : storageArray++ ;
40244 : }
40245 : }
40246 2 : delete [] storageArraySgSymbolTable;
40247 2 : SgSymbolTableStorageClass :: deleteStaticDataOfEasyStorageClasses();
40248 :
40249 :
40250 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateArgument );
40251 2 : SgTemplateArgumentStorageClass* storageArraySgTemplateArgument = NULL;
40252 2 : if ( 0 < sizeOfActualPool )
40253 : {
40254 1 : storageArraySgTemplateArgument = new SgTemplateArgumentStorageClass[sizeOfActualPool] ;
40255 1 : inFile.read ( (char*) (storageArraySgTemplateArgument) , sizeof ( SgTemplateArgumentStorageClass ) * sizeOfActualPool) ;
40256 : SgTemplateArgumentStorageClass* storageArray = storageArraySgTemplateArgument;
40257 6726 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40258 : {
40259 6725 : SgTemplateArgument* tmp = new SgTemplateArgument ( *storageArray ) ;
40260 6725 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40261 6725 : storageArray++ ;
40262 : }
40263 : }
40264 1 : delete [] storageArraySgTemplateArgument;
40265 :
40266 :
40267 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateArgumentList );
40268 2 : SgTemplateArgumentListStorageClass* storageArraySgTemplateArgumentList = NULL;
40269 2 : if ( 0 < sizeOfActualPool )
40270 : {
40271 0 : storageArraySgTemplateArgumentList = new SgTemplateArgumentListStorageClass[sizeOfActualPool] ;
40272 0 : inFile.read ( (char*) (storageArraySgTemplateArgumentList) , sizeof ( SgTemplateArgumentListStorageClass ) * sizeOfActualPool) ;
40273 0 : SgTemplateArgumentListStorageClass :: readEasyStorageDataFromFile(inFile) ;
40274 : SgTemplateArgumentListStorageClass* storageArray = storageArraySgTemplateArgumentList;
40275 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40276 : {
40277 0 : SgTemplateArgumentList* tmp = new SgTemplateArgumentList ( *storageArray ) ;
40278 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40279 0 : storageArray++ ;
40280 : }
40281 : }
40282 0 : delete [] storageArraySgTemplateArgumentList;
40283 2 : SgTemplateArgumentListStorageClass :: deleteStaticDataOfEasyStorageClasses();
40284 :
40285 :
40286 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateDeclaration );
40287 2 : SgTemplateDeclarationStorageClass* storageArraySgTemplateDeclaration = NULL;
40288 2 : if ( 0 < sizeOfActualPool )
40289 : {
40290 0 : storageArraySgTemplateDeclaration = new SgTemplateDeclarationStorageClass[sizeOfActualPool] ;
40291 0 : inFile.read ( (char*) (storageArraySgTemplateDeclaration) , sizeof ( SgTemplateDeclarationStorageClass ) * sizeOfActualPool) ;
40292 0 : SgTemplateDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40293 : SgTemplateDeclarationStorageClass* storageArray = storageArraySgTemplateDeclaration;
40294 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40295 : {
40296 0 : SgTemplateDeclaration* tmp = new SgTemplateDeclaration ( *storageArray ) ;
40297 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40298 0 : storageArray++ ;
40299 : }
40300 : }
40301 0 : delete [] storageArraySgTemplateDeclaration;
40302 2 : SgTemplateDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40303 :
40304 :
40305 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateClassDeclaration );
40306 2 : SgTemplateClassDeclarationStorageClass* storageArraySgTemplateClassDeclaration = NULL;
40307 2 : if ( 0 < sizeOfActualPool )
40308 : {
40309 1091 : storageArraySgTemplateClassDeclaration = new SgTemplateClassDeclarationStorageClass[sizeOfActualPool] ;
40310 1 : inFile.read ( (char*) (storageArraySgTemplateClassDeclaration) , sizeof ( SgTemplateClassDeclarationStorageClass ) * sizeOfActualPool) ;
40311 1 : SgTemplateClassDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40312 : SgTemplateClassDeclarationStorageClass* storageArray = storageArraySgTemplateClassDeclaration;
40313 1091 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40314 : {
40315 1090 : SgTemplateClassDeclaration* tmp = new SgTemplateClassDeclaration ( *storageArray ) ;
40316 1090 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40317 1090 : storageArray++ ;
40318 : }
40319 : }
40320 1 : delete [] storageArraySgTemplateClassDeclaration;
40321 2 : SgTemplateClassDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40322 :
40323 :
40324 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateClassSymbol );
40325 2 : SgTemplateClassSymbolStorageClass* storageArraySgTemplateClassSymbol = NULL;
40326 2 : if ( 0 < sizeOfActualPool )
40327 : {
40328 573 : storageArraySgTemplateClassSymbol = new SgTemplateClassSymbolStorageClass[sizeOfActualPool] ;
40329 1 : inFile.read ( (char*) (storageArraySgTemplateClassSymbol) , sizeof ( SgTemplateClassSymbolStorageClass ) * sizeOfActualPool) ;
40330 1 : SgTemplateClassSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40331 : SgTemplateClassSymbolStorageClass* storageArray = storageArraySgTemplateClassSymbol;
40332 573 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40333 : {
40334 572 : SgTemplateClassSymbol* tmp = new SgTemplateClassSymbol ( *storageArray ) ;
40335 572 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40336 572 : storageArray++ ;
40337 : }
40338 : }
40339 1 : delete [] storageArraySgTemplateClassSymbol;
40340 2 : SgTemplateClassSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40341 :
40342 :
40343 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateFunctionDeclaration );
40344 2 : SgTemplateFunctionDeclarationStorageClass* storageArraySgTemplateFunctionDeclaration = NULL;
40345 2 : if ( 0 < sizeOfActualPool )
40346 : {
40347 677 : storageArraySgTemplateFunctionDeclaration = new SgTemplateFunctionDeclarationStorageClass[sizeOfActualPool] ;
40348 1 : inFile.read ( (char*) (storageArraySgTemplateFunctionDeclaration) , sizeof ( SgTemplateFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
40349 1 : SgTemplateFunctionDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40350 : SgTemplateFunctionDeclarationStorageClass* storageArray = storageArraySgTemplateFunctionDeclaration;
40351 677 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40352 : {
40353 676 : SgTemplateFunctionDeclaration* tmp = new SgTemplateFunctionDeclaration ( *storageArray ) ;
40354 676 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40355 676 : storageArray++ ;
40356 : }
40357 : }
40358 1 : delete [] storageArraySgTemplateFunctionDeclaration;
40359 2 : SgTemplateFunctionDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40360 :
40361 :
40362 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateFunctionRefExp );
40363 2 : SgTemplateFunctionRefExpStorageClass* storageArraySgTemplateFunctionRefExp = NULL;
40364 2 : if ( 0 < sizeOfActualPool )
40365 : {
40366 226 : storageArraySgTemplateFunctionRefExp = new SgTemplateFunctionRefExpStorageClass[sizeOfActualPool] ;
40367 1 : inFile.read ( (char*) (storageArraySgTemplateFunctionRefExp) , sizeof ( SgTemplateFunctionRefExpStorageClass ) * sizeOfActualPool) ;
40368 1 : SgTemplateFunctionRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40369 : SgTemplateFunctionRefExpStorageClass* storageArray = storageArraySgTemplateFunctionRefExp;
40370 226 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40371 : {
40372 225 : SgTemplateFunctionRefExp* tmp = new SgTemplateFunctionRefExp ( *storageArray ) ;
40373 225 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40374 225 : storageArray++ ;
40375 : }
40376 : }
40377 1 : delete [] storageArraySgTemplateFunctionRefExp;
40378 2 : SgTemplateFunctionRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40379 :
40380 :
40381 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateFunctionSymbol );
40382 2 : SgTemplateFunctionSymbolStorageClass* storageArraySgTemplateFunctionSymbol = NULL;
40383 2 : if ( 0 < sizeOfActualPool )
40384 : {
40385 341 : storageArraySgTemplateFunctionSymbol = new SgTemplateFunctionSymbolStorageClass[sizeOfActualPool] ;
40386 1 : inFile.read ( (char*) (storageArraySgTemplateFunctionSymbol) , sizeof ( SgTemplateFunctionSymbolStorageClass ) * sizeOfActualPool) ;
40387 1 : SgTemplateFunctionSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40388 : SgTemplateFunctionSymbolStorageClass* storageArray = storageArraySgTemplateFunctionSymbol;
40389 341 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40390 : {
40391 340 : SgTemplateFunctionSymbol* tmp = new SgTemplateFunctionSymbol ( *storageArray ) ;
40392 340 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40393 340 : storageArray++ ;
40394 : }
40395 : }
40396 1 : delete [] storageArraySgTemplateFunctionSymbol;
40397 2 : SgTemplateFunctionSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40398 :
40399 :
40400 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateMemberFunctionDeclaration );
40401 2 : SgTemplateMemberFunctionDeclarationStorageClass* storageArraySgTemplateMemberFunctionDeclaration = NULL;
40402 2 : if ( 0 < sizeOfActualPool )
40403 : {
40404 1906 : storageArraySgTemplateMemberFunctionDeclaration = new SgTemplateMemberFunctionDeclarationStorageClass[sizeOfActualPool] ;
40405 1 : inFile.read ( (char*) (storageArraySgTemplateMemberFunctionDeclaration) , sizeof ( SgTemplateMemberFunctionDeclarationStorageClass ) * sizeOfActualPool) ;
40406 1 : SgTemplateMemberFunctionDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40407 : SgTemplateMemberFunctionDeclarationStorageClass* storageArray = storageArraySgTemplateMemberFunctionDeclaration;
40408 1906 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40409 : {
40410 1905 : SgTemplateMemberFunctionDeclaration* tmp = new SgTemplateMemberFunctionDeclaration ( *storageArray ) ;
40411 1905 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40412 1905 : storageArray++ ;
40413 : }
40414 : }
40415 1 : delete [] storageArraySgTemplateMemberFunctionDeclaration;
40416 2 : SgTemplateMemberFunctionDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40417 :
40418 :
40419 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateMemberFunctionRefExp );
40420 2 : SgTemplateMemberFunctionRefExpStorageClass* storageArraySgTemplateMemberFunctionRefExp = NULL;
40421 2 : if ( 0 < sizeOfActualPool )
40422 : {
40423 739 : storageArraySgTemplateMemberFunctionRefExp = new SgTemplateMemberFunctionRefExpStorageClass[sizeOfActualPool] ;
40424 1 : inFile.read ( (char*) (storageArraySgTemplateMemberFunctionRefExp) , sizeof ( SgTemplateMemberFunctionRefExpStorageClass ) * sizeOfActualPool) ;
40425 1 : SgTemplateMemberFunctionRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40426 : SgTemplateMemberFunctionRefExpStorageClass* storageArray = storageArraySgTemplateMemberFunctionRefExp;
40427 739 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40428 : {
40429 738 : SgTemplateMemberFunctionRefExp* tmp = new SgTemplateMemberFunctionRefExp ( *storageArray ) ;
40430 738 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40431 738 : storageArray++ ;
40432 : }
40433 : }
40434 1 : delete [] storageArraySgTemplateMemberFunctionRefExp;
40435 2 : SgTemplateMemberFunctionRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40436 :
40437 :
40438 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateMemberFunctionSymbol );
40439 2 : SgTemplateMemberFunctionSymbolStorageClass* storageArraySgTemplateMemberFunctionSymbol = NULL;
40440 2 : if ( 0 < sizeOfActualPool )
40441 : {
40442 1048 : storageArraySgTemplateMemberFunctionSymbol = new SgTemplateMemberFunctionSymbolStorageClass[sizeOfActualPool] ;
40443 1 : inFile.read ( (char*) (storageArraySgTemplateMemberFunctionSymbol) , sizeof ( SgTemplateMemberFunctionSymbolStorageClass ) * sizeOfActualPool) ;
40444 1 : SgTemplateMemberFunctionSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40445 : SgTemplateMemberFunctionSymbolStorageClass* storageArray = storageArraySgTemplateMemberFunctionSymbol;
40446 1048 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40447 : {
40448 1047 : SgTemplateMemberFunctionSymbol* tmp = new SgTemplateMemberFunctionSymbol ( *storageArray ) ;
40449 1047 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40450 1047 : storageArray++ ;
40451 : }
40452 : }
40453 1 : delete [] storageArraySgTemplateMemberFunctionSymbol;
40454 2 : SgTemplateMemberFunctionSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40455 :
40456 :
40457 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateTypedefDeclaration );
40458 2 : SgTemplateTypedefDeclarationStorageClass* storageArraySgTemplateTypedefDeclaration = NULL;
40459 2 : if ( 0 < sizeOfActualPool )
40460 : {
40461 96 : storageArraySgTemplateTypedefDeclaration = new SgTemplateTypedefDeclarationStorageClass[sizeOfActualPool] ;
40462 1 : inFile.read ( (char*) (storageArraySgTemplateTypedefDeclaration) , sizeof ( SgTemplateTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
40463 1 : SgTemplateTypedefDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40464 : SgTemplateTypedefDeclarationStorageClass* storageArray = storageArraySgTemplateTypedefDeclaration;
40465 96 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40466 : {
40467 95 : SgTemplateTypedefDeclaration* tmp = new SgTemplateTypedefDeclaration ( *storageArray ) ;
40468 95 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40469 95 : storageArray++ ;
40470 : }
40471 : }
40472 1 : delete [] storageArraySgTemplateTypedefDeclaration;
40473 2 : SgTemplateTypedefDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40474 :
40475 :
40476 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateTypedefSymbol );
40477 2 : SgTemplateTypedefSymbolStorageClass* storageArraySgTemplateTypedefSymbol = NULL;
40478 2 : if ( 0 < sizeOfActualPool )
40479 : {
40480 161 : storageArraySgTemplateTypedefSymbol = new SgTemplateTypedefSymbolStorageClass[sizeOfActualPool] ;
40481 1 : inFile.read ( (char*) (storageArraySgTemplateTypedefSymbol) , sizeof ( SgTemplateTypedefSymbolStorageClass ) * sizeOfActualPool) ;
40482 1 : SgTemplateTypedefSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40483 : SgTemplateTypedefSymbolStorageClass* storageArray = storageArraySgTemplateTypedefSymbol;
40484 161 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40485 : {
40486 160 : SgTemplateTypedefSymbol* tmp = new SgTemplateTypedefSymbol ( *storageArray ) ;
40487 160 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40488 160 : storageArray++ ;
40489 : }
40490 : }
40491 1 : delete [] storageArraySgTemplateTypedefSymbol;
40492 2 : SgTemplateTypedefSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40493 :
40494 :
40495 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateVariableDeclaration );
40496 2 : SgTemplateVariableDeclarationStorageClass* storageArraySgTemplateVariableDeclaration = NULL;
40497 2 : if ( 0 < sizeOfActualPool )
40498 : {
40499 103 : storageArraySgTemplateVariableDeclaration = new SgTemplateVariableDeclarationStorageClass[sizeOfActualPool] ;
40500 1 : inFile.read ( (char*) (storageArraySgTemplateVariableDeclaration) , sizeof ( SgTemplateVariableDeclarationStorageClass ) * sizeOfActualPool) ;
40501 1 : SgTemplateVariableDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40502 : SgTemplateVariableDeclarationStorageClass* storageArray = storageArraySgTemplateVariableDeclaration;
40503 103 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40504 : {
40505 102 : SgTemplateVariableDeclaration* tmp = new SgTemplateVariableDeclaration ( *storageArray ) ;
40506 102 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40507 102 : storageArray++ ;
40508 : }
40509 : }
40510 1 : delete [] storageArraySgTemplateVariableDeclaration;
40511 2 : SgTemplateVariableDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40512 :
40513 :
40514 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateVariableSymbol );
40515 2 : SgTemplateVariableSymbolStorageClass* storageArraySgTemplateVariableSymbol = NULL;
40516 2 : if ( 0 < sizeOfActualPool )
40517 : {
40518 87 : storageArraySgTemplateVariableSymbol = new SgTemplateVariableSymbolStorageClass[sizeOfActualPool] ;
40519 1 : inFile.read ( (char*) (storageArraySgTemplateVariableSymbol) , sizeof ( SgTemplateVariableSymbolStorageClass ) * sizeOfActualPool) ;
40520 1 : SgTemplateVariableSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40521 : SgTemplateVariableSymbolStorageClass* storageArray = storageArraySgTemplateVariableSymbol;
40522 87 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40523 : {
40524 86 : SgTemplateVariableSymbol* tmp = new SgTemplateVariableSymbol ( *storageArray ) ;
40525 86 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40526 86 : storageArray++ ;
40527 : }
40528 : }
40529 1 : delete [] storageArraySgTemplateVariableSymbol;
40530 2 : SgTemplateVariableSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40531 :
40532 :
40533 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateClassDefinition );
40534 2 : SgTemplateClassDefinitionStorageClass* storageArraySgTemplateClassDefinition = NULL;
40535 2 : if ( 0 < sizeOfActualPool )
40536 : {
40537 507 : storageArraySgTemplateClassDefinition = new SgTemplateClassDefinitionStorageClass[sizeOfActualPool] ;
40538 1 : inFile.read ( (char*) (storageArraySgTemplateClassDefinition) , sizeof ( SgTemplateClassDefinitionStorageClass ) * sizeOfActualPool) ;
40539 1 : SgTemplateClassDefinitionStorageClass :: readEasyStorageDataFromFile(inFile) ;
40540 : SgTemplateClassDefinitionStorageClass* storageArray = storageArraySgTemplateClassDefinition;
40541 507 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40542 : {
40543 506 : SgTemplateClassDefinition* tmp = new SgTemplateClassDefinition ( *storageArray ) ;
40544 506 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40545 506 : storageArray++ ;
40546 : }
40547 : }
40548 1 : delete [] storageArraySgTemplateClassDefinition;
40549 2 : SgTemplateClassDefinitionStorageClass :: deleteStaticDataOfEasyStorageClasses();
40550 :
40551 :
40552 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateFunctionDefinition );
40553 2 : SgTemplateFunctionDefinitionStorageClass* storageArraySgTemplateFunctionDefinition = NULL;
40554 2 : if ( 0 < sizeOfActualPool )
40555 : {
40556 316 : storageArraySgTemplateFunctionDefinition = new SgTemplateFunctionDefinitionStorageClass[sizeOfActualPool] ;
40557 1 : inFile.read ( (char*) (storageArraySgTemplateFunctionDefinition) , sizeof ( SgTemplateFunctionDefinitionStorageClass ) * sizeOfActualPool) ;
40558 1 : SgTemplateFunctionDefinitionStorageClass :: readEasyStorageDataFromFile(inFile) ;
40559 : SgTemplateFunctionDefinitionStorageClass* storageArray = storageArraySgTemplateFunctionDefinition;
40560 316 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40561 : {
40562 315 : SgTemplateFunctionDefinition* tmp = new SgTemplateFunctionDefinition ( *storageArray ) ;
40563 315 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40564 315 : storageArray++ ;
40565 : }
40566 : }
40567 1 : delete [] storageArraySgTemplateFunctionDefinition;
40568 2 : SgTemplateFunctionDefinitionStorageClass :: deleteStaticDataOfEasyStorageClasses();
40569 :
40570 :
40571 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationDecl );
40572 2 : SgTemplateInstantiationDeclStorageClass* storageArraySgTemplateInstantiationDecl = NULL;
40573 2 : if ( 0 < sizeOfActualPool )
40574 : {
40575 1320 : storageArraySgTemplateInstantiationDecl = new SgTemplateInstantiationDeclStorageClass[sizeOfActualPool] ;
40576 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationDecl) , sizeof ( SgTemplateInstantiationDeclStorageClass ) * sizeOfActualPool) ;
40577 1 : SgTemplateInstantiationDeclStorageClass :: readEasyStorageDataFromFile(inFile) ;
40578 : SgTemplateInstantiationDeclStorageClass* storageArray = storageArraySgTemplateInstantiationDecl;
40579 1320 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40580 : {
40581 1319 : SgTemplateInstantiationDecl* tmp = new SgTemplateInstantiationDecl ( *storageArray ) ;
40582 1319 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40583 1319 : storageArray++ ;
40584 : }
40585 : }
40586 1 : delete [] storageArraySgTemplateInstantiationDecl;
40587 2 : SgTemplateInstantiationDeclStorageClass :: deleteStaticDataOfEasyStorageClasses();
40588 :
40589 :
40590 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationDefn );
40591 2 : SgTemplateInstantiationDefnStorageClass* storageArraySgTemplateInstantiationDefn = NULL;
40592 2 : if ( 0 < sizeOfActualPool )
40593 : {
40594 602 : storageArraySgTemplateInstantiationDefn = new SgTemplateInstantiationDefnStorageClass[sizeOfActualPool] ;
40595 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationDefn) , sizeof ( SgTemplateInstantiationDefnStorageClass ) * sizeOfActualPool) ;
40596 1 : SgTemplateInstantiationDefnStorageClass :: readEasyStorageDataFromFile(inFile) ;
40597 : SgTemplateInstantiationDefnStorageClass* storageArray = storageArraySgTemplateInstantiationDefn;
40598 602 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40599 : {
40600 601 : SgTemplateInstantiationDefn* tmp = new SgTemplateInstantiationDefn ( *storageArray ) ;
40601 601 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40602 601 : storageArray++ ;
40603 : }
40604 : }
40605 1 : delete [] storageArraySgTemplateInstantiationDefn;
40606 2 : SgTemplateInstantiationDefnStorageClass :: deleteStaticDataOfEasyStorageClasses();
40607 :
40608 :
40609 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationDirectiveStatement );
40610 2 : SgTemplateInstantiationDirectiveStatementStorageClass* storageArraySgTemplateInstantiationDirectiveStatement = NULL;
40611 2 : if ( 0 < sizeOfActualPool )
40612 : {
40613 125 : storageArraySgTemplateInstantiationDirectiveStatement = new SgTemplateInstantiationDirectiveStatementStorageClass[sizeOfActualPool] ;
40614 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationDirectiveStatement) , sizeof ( SgTemplateInstantiationDirectiveStatementStorageClass ) * sizeOfActualPool) ;
40615 1 : SgTemplateInstantiationDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
40616 : SgTemplateInstantiationDirectiveStatementStorageClass* storageArray = storageArraySgTemplateInstantiationDirectiveStatement;
40617 125 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40618 : {
40619 124 : SgTemplateInstantiationDirectiveStatement* tmp = new SgTemplateInstantiationDirectiveStatement ( *storageArray ) ;
40620 124 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40621 124 : storageArray++ ;
40622 : }
40623 : }
40624 1 : delete [] storageArraySgTemplateInstantiationDirectiveStatement;
40625 2 : SgTemplateInstantiationDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
40626 :
40627 :
40628 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationFunctionDecl );
40629 2 : SgTemplateInstantiationFunctionDeclStorageClass* storageArraySgTemplateInstantiationFunctionDecl = NULL;
40630 2 : if ( 0 < sizeOfActualPool )
40631 : {
40632 284 : storageArraySgTemplateInstantiationFunctionDecl = new SgTemplateInstantiationFunctionDeclStorageClass[sizeOfActualPool] ;
40633 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationFunctionDecl) , sizeof ( SgTemplateInstantiationFunctionDeclStorageClass ) * sizeOfActualPool) ;
40634 1 : SgTemplateInstantiationFunctionDeclStorageClass :: readEasyStorageDataFromFile(inFile) ;
40635 : SgTemplateInstantiationFunctionDeclStorageClass* storageArray = storageArraySgTemplateInstantiationFunctionDecl;
40636 284 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40637 : {
40638 283 : SgTemplateInstantiationFunctionDecl* tmp = new SgTemplateInstantiationFunctionDecl ( *storageArray ) ;
40639 283 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40640 283 : storageArray++ ;
40641 : }
40642 : }
40643 1 : delete [] storageArraySgTemplateInstantiationFunctionDecl;
40644 2 : SgTemplateInstantiationFunctionDeclStorageClass :: deleteStaticDataOfEasyStorageClasses();
40645 :
40646 :
40647 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationMemberFunctionDecl );
40648 2 : SgTemplateInstantiationMemberFunctionDeclStorageClass* storageArraySgTemplateInstantiationMemberFunctionDecl = NULL;
40649 2 : if ( 0 < sizeOfActualPool )
40650 : {
40651 1740 : storageArraySgTemplateInstantiationMemberFunctionDecl = new SgTemplateInstantiationMemberFunctionDeclStorageClass[sizeOfActualPool] ;
40652 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationMemberFunctionDecl) , sizeof ( SgTemplateInstantiationMemberFunctionDeclStorageClass ) * sizeOfActualPool) ;
40653 1 : SgTemplateInstantiationMemberFunctionDeclStorageClass :: readEasyStorageDataFromFile(inFile) ;
40654 : SgTemplateInstantiationMemberFunctionDeclStorageClass* storageArray = storageArraySgTemplateInstantiationMemberFunctionDecl;
40655 1740 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40656 : {
40657 1739 : SgTemplateInstantiationMemberFunctionDecl* tmp = new SgTemplateInstantiationMemberFunctionDecl ( *storageArray ) ;
40658 1739 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40659 1739 : storageArray++ ;
40660 : }
40661 : }
40662 1 : delete [] storageArraySgTemplateInstantiationMemberFunctionDecl;
40663 2 : SgTemplateInstantiationMemberFunctionDeclStorageClass :: deleteStaticDataOfEasyStorageClasses();
40664 :
40665 :
40666 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateInstantiationTypedefDeclaration );
40667 2 : SgTemplateInstantiationTypedefDeclarationStorageClass* storageArraySgTemplateInstantiationTypedefDeclaration = NULL;
40668 2 : if ( 0 < sizeOfActualPool )
40669 : {
40670 66 : storageArraySgTemplateInstantiationTypedefDeclaration = new SgTemplateInstantiationTypedefDeclarationStorageClass[sizeOfActualPool] ;
40671 1 : inFile.read ( (char*) (storageArraySgTemplateInstantiationTypedefDeclaration) , sizeof ( SgTemplateInstantiationTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
40672 1 : SgTemplateInstantiationTypedefDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
40673 : SgTemplateInstantiationTypedefDeclarationStorageClass* storageArray = storageArraySgTemplateInstantiationTypedefDeclaration;
40674 66 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40675 : {
40676 65 : SgTemplateInstantiationTypedefDeclaration* tmp = new SgTemplateInstantiationTypedefDeclaration ( *storageArray ) ;
40677 65 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40678 65 : storageArray++ ;
40679 : }
40680 : }
40681 1 : delete [] storageArraySgTemplateInstantiationTypedefDeclaration;
40682 2 : SgTemplateInstantiationTypedefDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
40683 :
40684 :
40685 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateParameter );
40686 2 : SgTemplateParameterStorageClass* storageArraySgTemplateParameter = NULL;
40687 2 : if ( 0 < sizeOfActualPool )
40688 : {
40689 1 : storageArraySgTemplateParameter = new SgTemplateParameterStorageClass[sizeOfActualPool] ;
40690 1 : inFile.read ( (char*) (storageArraySgTemplateParameter) , sizeof ( SgTemplateParameterStorageClass ) * sizeOfActualPool) ;
40691 : SgTemplateParameterStorageClass* storageArray = storageArraySgTemplateParameter;
40692 2168 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40693 : {
40694 2167 : SgTemplateParameter* tmp = new SgTemplateParameter ( *storageArray ) ;
40695 2167 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40696 2167 : storageArray++ ;
40697 : }
40698 : }
40699 1 : delete [] storageArraySgTemplateParameter;
40700 :
40701 :
40702 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateParameterVal );
40703 2 : SgTemplateParameterValStorageClass* storageArraySgTemplateParameterVal = NULL;
40704 2 : if ( 0 < sizeOfActualPool )
40705 : {
40706 0 : storageArraySgTemplateParameterVal = new SgTemplateParameterValStorageClass[sizeOfActualPool] ;
40707 0 : inFile.read ( (char*) (storageArraySgTemplateParameterVal) , sizeof ( SgTemplateParameterValStorageClass ) * sizeOfActualPool) ;
40708 0 : SgTemplateParameterValStorageClass :: readEasyStorageDataFromFile(inFile) ;
40709 : SgTemplateParameterValStorageClass* storageArray = storageArraySgTemplateParameterVal;
40710 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40711 : {
40712 0 : SgTemplateParameterVal* tmp = new SgTemplateParameterVal ( *storageArray ) ;
40713 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40714 0 : storageArray++ ;
40715 : }
40716 : }
40717 0 : delete [] storageArraySgTemplateParameterVal;
40718 2 : SgTemplateParameterValStorageClass :: deleteStaticDataOfEasyStorageClasses();
40719 :
40720 :
40721 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateParameterList );
40722 2 : SgTemplateParameterListStorageClass* storageArraySgTemplateParameterList = NULL;
40723 2 : if ( 0 < sizeOfActualPool )
40724 : {
40725 0 : storageArraySgTemplateParameterList = new SgTemplateParameterListStorageClass[sizeOfActualPool] ;
40726 0 : inFile.read ( (char*) (storageArraySgTemplateParameterList) , sizeof ( SgTemplateParameterListStorageClass ) * sizeOfActualPool) ;
40727 0 : SgTemplateParameterListStorageClass :: readEasyStorageDataFromFile(inFile) ;
40728 : SgTemplateParameterListStorageClass* storageArray = storageArraySgTemplateParameterList;
40729 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40730 : {
40731 0 : SgTemplateParameterList* tmp = new SgTemplateParameterList ( *storageArray ) ;
40732 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40733 0 : storageArray++ ;
40734 : }
40735 : }
40736 0 : delete [] storageArraySgTemplateParameterList;
40737 2 : SgTemplateParameterListStorageClass :: deleteStaticDataOfEasyStorageClasses();
40738 :
40739 :
40740 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateSymbol );
40741 2 : SgTemplateSymbolStorageClass* storageArraySgTemplateSymbol = NULL;
40742 2 : if ( 0 < sizeOfActualPool )
40743 : {
40744 0 : storageArraySgTemplateSymbol = new SgTemplateSymbolStorageClass[sizeOfActualPool] ;
40745 0 : inFile.read ( (char*) (storageArraySgTemplateSymbol) , sizeof ( SgTemplateSymbolStorageClass ) * sizeOfActualPool) ;
40746 0 : SgTemplateSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40747 : SgTemplateSymbolStorageClass* storageArray = storageArraySgTemplateSymbol;
40748 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40749 : {
40750 0 : SgTemplateSymbol* tmp = new SgTemplateSymbol ( *storageArray ) ;
40751 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40752 0 : storageArray++ ;
40753 : }
40754 : }
40755 0 : delete [] storageArraySgTemplateSymbol;
40756 2 : SgTemplateSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40757 :
40758 :
40759 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTemplateType );
40760 2 : SgTemplateTypeStorageClass* storageArraySgTemplateType = NULL;
40761 2 : if ( 0 < sizeOfActualPool )
40762 : {
40763 0 : storageArraySgTemplateType = new SgTemplateTypeStorageClass[sizeOfActualPool] ;
40764 0 : inFile.read ( (char*) (storageArraySgTemplateType) , sizeof ( SgTemplateTypeStorageClass ) * sizeOfActualPool) ;
40765 0 : SgTemplateTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
40766 : SgTemplateTypeStorageClass* storageArray = storageArraySgTemplateType;
40767 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40768 : {
40769 0 : SgTemplateType* tmp = new SgTemplateType ( *storageArray ) ;
40770 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40771 0 : storageArray++ ;
40772 : }
40773 : }
40774 0 : delete [] storageArraySgTemplateType;
40775 2 : SgTemplateTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
40776 :
40777 :
40778 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgThisExp );
40779 2 : SgThisExpStorageClass* storageArraySgThisExp = NULL;
40780 2 : if ( 0 < sizeOfActualPool )
40781 : {
40782 1237 : storageArraySgThisExp = new SgThisExpStorageClass[sizeOfActualPool] ;
40783 1 : inFile.read ( (char*) (storageArraySgThisExp) , sizeof ( SgThisExpStorageClass ) * sizeOfActualPool) ;
40784 1 : SgThisExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40785 : SgThisExpStorageClass* storageArray = storageArraySgThisExp;
40786 1237 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40787 : {
40788 1236 : SgThisExp* tmp = new SgThisExp ( *storageArray ) ;
40789 1236 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40790 1236 : storageArray++ ;
40791 : }
40792 : }
40793 1 : delete [] storageArraySgThisExp;
40794 2 : SgThisExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40795 :
40796 :
40797 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeTraitBuiltinOperator );
40798 2 : SgTypeTraitBuiltinOperatorStorageClass* storageArraySgTypeTraitBuiltinOperator = NULL;
40799 2 : if ( 0 < sizeOfActualPool )
40800 : {
40801 43 : storageArraySgTypeTraitBuiltinOperator = new SgTypeTraitBuiltinOperatorStorageClass[sizeOfActualPool] ;
40802 1 : inFile.read ( (char*) (storageArraySgTypeTraitBuiltinOperator) , sizeof ( SgTypeTraitBuiltinOperatorStorageClass ) * sizeOfActualPool) ;
40803 1 : SgTypeTraitBuiltinOperatorStorageClass :: readEasyStorageDataFromFile(inFile) ;
40804 : SgTypeTraitBuiltinOperatorStorageClass* storageArray = storageArraySgTypeTraitBuiltinOperator;
40805 43 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40806 : {
40807 42 : SgTypeTraitBuiltinOperator* tmp = new SgTypeTraitBuiltinOperator ( *storageArray ) ;
40808 42 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40809 42 : storageArray++ ;
40810 : }
40811 : }
40812 1 : delete [] storageArraySgTypeTraitBuiltinOperator;
40813 2 : SgTypeTraitBuiltinOperatorStorageClass :: deleteStaticDataOfEasyStorageClasses();
40814 :
40815 :
40816 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgSuperExp );
40817 2 : SgSuperExpStorageClass* storageArraySgSuperExp = NULL;
40818 2 : if ( 0 < sizeOfActualPool )
40819 : {
40820 0 : storageArraySgSuperExp = new SgSuperExpStorageClass[sizeOfActualPool] ;
40821 0 : inFile.read ( (char*) (storageArraySgSuperExp) , sizeof ( SgSuperExpStorageClass ) * sizeOfActualPool) ;
40822 0 : SgSuperExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40823 : SgSuperExpStorageClass* storageArray = storageArraySgSuperExp;
40824 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40825 : {
40826 0 : SgSuperExp* tmp = new SgSuperExp ( *storageArray ) ;
40827 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40828 0 : storageArray++ ;
40829 : }
40830 : }
40831 0 : delete [] storageArraySgSuperExp;
40832 2 : SgSuperExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40833 :
40834 :
40835 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgThrowOp );
40836 2 : SgThrowOpStorageClass* storageArraySgThrowOp = NULL;
40837 2 : if ( 0 < sizeOfActualPool )
40838 : {
40839 53 : storageArraySgThrowOp = new SgThrowOpStorageClass[sizeOfActualPool] ;
40840 1 : inFile.read ( (char*) (storageArraySgThrowOp) , sizeof ( SgThrowOpStorageClass ) * sizeOfActualPool) ;
40841 1 : SgThrowOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40842 : SgThrowOpStorageClass* storageArray = storageArraySgThrowOp;
40843 53 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40844 : {
40845 52 : SgThrowOp* tmp = new SgThrowOp ( *storageArray ) ;
40846 52 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40847 52 : storageArray++ ;
40848 : }
40849 : }
40850 1 : delete [] storageArraySgThrowOp;
40851 2 : SgThrowOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40852 :
40853 :
40854 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgToken );
40855 2 : SgTokenStorageClass* storageArraySgToken = NULL;
40856 2 : if ( 0 < sizeOfActualPool )
40857 : {
40858 0 : storageArraySgToken = new SgTokenStorageClass[sizeOfActualPool] ;
40859 0 : inFile.read ( (char*) (storageArraySgToken) , sizeof ( SgTokenStorageClass ) * sizeOfActualPool) ;
40860 0 : SgTokenStorageClass :: readEasyStorageDataFromFile(inFile) ;
40861 : SgTokenStorageClass* storageArray = storageArraySgToken;
40862 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40863 : {
40864 0 : SgToken* tmp = new SgToken ( *storageArray ) ;
40865 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40866 0 : storageArray++ ;
40867 : }
40868 : }
40869 0 : delete [] storageArraySgToken;
40870 2 : SgTokenStorageClass :: deleteStaticDataOfEasyStorageClasses();
40871 :
40872 :
40873 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTryStmt );
40874 2 : SgTryStmtStorageClass* storageArraySgTryStmt = NULL;
40875 2 : if ( 0 < sizeOfActualPool )
40876 : {
40877 55 : storageArraySgTryStmt = new SgTryStmtStorageClass[sizeOfActualPool] ;
40878 1 : inFile.read ( (char*) (storageArraySgTryStmt) , sizeof ( SgTryStmtStorageClass ) * sizeOfActualPool) ;
40879 1 : SgTryStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
40880 : SgTryStmtStorageClass* storageArray = storageArraySgTryStmt;
40881 55 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40882 : {
40883 54 : SgTryStmt* tmp = new SgTryStmt ( *storageArray ) ;
40884 54 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40885 54 : storageArray++ ;
40886 : }
40887 : }
40888 1 : delete [] storageArraySgTryStmt;
40889 2 : SgTryStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
40890 :
40891 :
40892 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTupleExp );
40893 2 : SgTupleExpStorageClass* storageArraySgTupleExp = NULL;
40894 2 : if ( 0 < sizeOfActualPool )
40895 : {
40896 0 : storageArraySgTupleExp = new SgTupleExpStorageClass[sizeOfActualPool] ;
40897 0 : inFile.read ( (char*) (storageArraySgTupleExp) , sizeof ( SgTupleExpStorageClass ) * sizeOfActualPool) ;
40898 0 : SgTupleExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
40899 : SgTupleExpStorageClass* storageArray = storageArraySgTupleExp;
40900 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40901 : {
40902 0 : SgTupleExp* tmp = new SgTupleExp ( *storageArray ) ;
40903 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40904 0 : storageArray++ ;
40905 : }
40906 : }
40907 0 : delete [] storageArraySgTupleExp;
40908 2 : SgTupleExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
40909 :
40910 :
40911 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgType );
40912 2 : SgTypeStorageClass* storageArraySgType = NULL;
40913 2 : if ( 0 < sizeOfActualPool )
40914 : {
40915 0 : storageArraySgType = new SgTypeStorageClass[sizeOfActualPool] ;
40916 0 : inFile.read ( (char*) (storageArraySgType) , sizeof ( SgTypeStorageClass ) * sizeOfActualPool) ;
40917 0 : SgTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
40918 : SgTypeStorageClass* storageArray = storageArraySgType;
40919 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40920 : {
40921 0 : SgType* tmp = new SgType ( *storageArray ) ;
40922 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40923 0 : storageArray++ ;
40924 : }
40925 : }
40926 0 : delete [] storageArraySgType;
40927 2 : SgTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
40928 :
40929 :
40930 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeBool );
40931 2 : SgTypeBoolStorageClass* storageArraySgTypeBool = NULL;
40932 2 : if ( 0 < sizeOfActualPool )
40933 : {
40934 2 : storageArraySgTypeBool = new SgTypeBoolStorageClass[sizeOfActualPool] ;
40935 1 : inFile.read ( (char*) (storageArraySgTypeBool) , sizeof ( SgTypeBoolStorageClass ) * sizeOfActualPool) ;
40936 1 : SgTypeBoolStorageClass :: readEasyStorageDataFromFile(inFile) ;
40937 : SgTypeBoolStorageClass* storageArray = storageArraySgTypeBool;
40938 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40939 : {
40940 1 : SgTypeBool* tmp = new SgTypeBool ( *storageArray ) ;
40941 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40942 1 : storageArray++ ;
40943 : }
40944 : }
40945 1 : delete [] storageArraySgTypeBool;
40946 2 : SgTypeBoolStorageClass :: deleteStaticDataOfEasyStorageClasses();
40947 :
40948 :
40949 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeChar );
40950 2 : SgTypeCharStorageClass* storageArraySgTypeChar = NULL;
40951 2 : if ( 0 < sizeOfActualPool )
40952 : {
40953 4 : storageArraySgTypeChar = new SgTypeCharStorageClass[sizeOfActualPool] ;
40954 2 : inFile.read ( (char*) (storageArraySgTypeChar) , sizeof ( SgTypeCharStorageClass ) * sizeOfActualPool) ;
40955 2 : SgTypeCharStorageClass :: readEasyStorageDataFromFile(inFile) ;
40956 : SgTypeCharStorageClass* storageArray = storageArraySgTypeChar;
40957 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40958 : {
40959 2 : SgTypeChar* tmp = new SgTypeChar ( *storageArray ) ;
40960 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40961 2 : storageArray++ ;
40962 : }
40963 : }
40964 2 : delete [] storageArraySgTypeChar;
40965 2 : SgTypeCharStorageClass :: deleteStaticDataOfEasyStorageClasses();
40966 :
40967 :
40968 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeChar16 );
40969 2 : SgTypeChar16StorageClass* storageArraySgTypeChar16 = NULL;
40970 2 : if ( 0 < sizeOfActualPool )
40971 : {
40972 2 : storageArraySgTypeChar16 = new SgTypeChar16StorageClass[sizeOfActualPool] ;
40973 1 : inFile.read ( (char*) (storageArraySgTypeChar16) , sizeof ( SgTypeChar16StorageClass ) * sizeOfActualPool) ;
40974 1 : SgTypeChar16StorageClass :: readEasyStorageDataFromFile(inFile) ;
40975 : SgTypeChar16StorageClass* storageArray = storageArraySgTypeChar16;
40976 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40977 : {
40978 1 : SgTypeChar16* tmp = new SgTypeChar16 ( *storageArray ) ;
40979 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40980 1 : storageArray++ ;
40981 : }
40982 : }
40983 1 : delete [] storageArraySgTypeChar16;
40984 2 : SgTypeChar16StorageClass :: deleteStaticDataOfEasyStorageClasses();
40985 :
40986 :
40987 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeChar32 );
40988 2 : SgTypeChar32StorageClass* storageArraySgTypeChar32 = NULL;
40989 2 : if ( 0 < sizeOfActualPool )
40990 : {
40991 2 : storageArraySgTypeChar32 = new SgTypeChar32StorageClass[sizeOfActualPool] ;
40992 1 : inFile.read ( (char*) (storageArraySgTypeChar32) , sizeof ( SgTypeChar32StorageClass ) * sizeOfActualPool) ;
40993 1 : SgTypeChar32StorageClass :: readEasyStorageDataFromFile(inFile) ;
40994 : SgTypeChar32StorageClass* storageArray = storageArraySgTypeChar32;
40995 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
40996 : {
40997 1 : SgTypeChar32* tmp = new SgTypeChar32 ( *storageArray ) ;
40998 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
40999 1 : storageArray++ ;
41000 : }
41001 : }
41002 1 : delete [] storageArraySgTypeChar32;
41003 2 : SgTypeChar32StorageClass :: deleteStaticDataOfEasyStorageClasses();
41004 :
41005 :
41006 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeComplex );
41007 2 : SgTypeComplexStorageClass* storageArraySgTypeComplex = NULL;
41008 2 : if ( 0 < sizeOfActualPool )
41009 : {
41010 9 : storageArraySgTypeComplex = new SgTypeComplexStorageClass[sizeOfActualPool] ;
41011 2 : inFile.read ( (char*) (storageArraySgTypeComplex) , sizeof ( SgTypeComplexStorageClass ) * sizeOfActualPool) ;
41012 2 : SgTypeComplexStorageClass :: readEasyStorageDataFromFile(inFile) ;
41013 : SgTypeComplexStorageClass* storageArray = storageArraySgTypeComplex;
41014 9 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41015 : {
41016 7 : SgTypeComplex* tmp = new SgTypeComplex ( *storageArray ) ;
41017 7 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41018 7 : storageArray++ ;
41019 : }
41020 : }
41021 2 : delete [] storageArraySgTypeComplex;
41022 2 : SgTypeComplexStorageClass :: deleteStaticDataOfEasyStorageClasses();
41023 :
41024 :
41025 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeDefault );
41026 2 : SgTypeDefaultStorageClass* storageArraySgTypeDefault = NULL;
41027 2 : if ( 0 < sizeOfActualPool )
41028 : {
41029 6 : storageArraySgTypeDefault = new SgTypeDefaultStorageClass[sizeOfActualPool] ;
41030 2 : inFile.read ( (char*) (storageArraySgTypeDefault) , sizeof ( SgTypeDefaultStorageClass ) * sizeOfActualPool) ;
41031 2 : SgTypeDefaultStorageClass :: readEasyStorageDataFromFile(inFile) ;
41032 : SgTypeDefaultStorageClass* storageArray = storageArraySgTypeDefault;
41033 6 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41034 : {
41035 4 : SgTypeDefault* tmp = new SgTypeDefault ( *storageArray ) ;
41036 4 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41037 4 : storageArray++ ;
41038 : }
41039 : }
41040 2 : delete [] storageArraySgTypeDefault;
41041 2 : SgTypeDefaultStorageClass :: deleteStaticDataOfEasyStorageClasses();
41042 :
41043 :
41044 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeExpression );
41045 2 : SgTypeExpressionStorageClass* storageArraySgTypeExpression = NULL;
41046 2 : if ( 0 < sizeOfActualPool )
41047 : {
41048 0 : storageArraySgTypeExpression = new SgTypeExpressionStorageClass[sizeOfActualPool] ;
41049 0 : inFile.read ( (char*) (storageArraySgTypeExpression) , sizeof ( SgTypeExpressionStorageClass ) * sizeOfActualPool) ;
41050 0 : SgTypeExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
41051 : SgTypeExpressionStorageClass* storageArray = storageArraySgTypeExpression;
41052 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41053 : {
41054 0 : SgTypeExpression* tmp = new SgTypeExpression ( *storageArray ) ;
41055 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41056 0 : storageArray++ ;
41057 : }
41058 : }
41059 0 : delete [] storageArraySgTypeExpression;
41060 2 : SgTypeExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
41061 :
41062 :
41063 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeLabel );
41064 2 : SgTypeLabelStorageClass* storageArraySgTypeLabel = NULL;
41065 2 : if ( 0 < sizeOfActualPool )
41066 : {
41067 0 : storageArraySgTypeLabel = new SgTypeLabelStorageClass[sizeOfActualPool] ;
41068 0 : inFile.read ( (char*) (storageArraySgTypeLabel) , sizeof ( SgTypeLabelStorageClass ) * sizeOfActualPool) ;
41069 0 : SgTypeLabelStorageClass :: readEasyStorageDataFromFile(inFile) ;
41070 : SgTypeLabelStorageClass* storageArray = storageArraySgTypeLabel;
41071 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41072 : {
41073 0 : SgTypeLabel* tmp = new SgTypeLabel ( *storageArray ) ;
41074 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41075 0 : storageArray++ ;
41076 : }
41077 : }
41078 0 : delete [] storageArraySgTypeLabel;
41079 2 : SgTypeLabelStorageClass :: deleteStaticDataOfEasyStorageClasses();
41080 :
41081 :
41082 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeDouble );
41083 2 : SgTypeDoubleStorageClass* storageArraySgTypeDouble = NULL;
41084 2 : if ( 0 < sizeOfActualPool )
41085 : {
41086 4 : storageArraySgTypeDouble = new SgTypeDoubleStorageClass[sizeOfActualPool] ;
41087 2 : inFile.read ( (char*) (storageArraySgTypeDouble) , sizeof ( SgTypeDoubleStorageClass ) * sizeOfActualPool) ;
41088 2 : SgTypeDoubleStorageClass :: readEasyStorageDataFromFile(inFile) ;
41089 : SgTypeDoubleStorageClass* storageArray = storageArraySgTypeDouble;
41090 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41091 : {
41092 2 : SgTypeDouble* tmp = new SgTypeDouble ( *storageArray ) ;
41093 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41094 2 : storageArray++ ;
41095 : }
41096 : }
41097 2 : delete [] storageArraySgTypeDouble;
41098 2 : SgTypeDoubleStorageClass :: deleteStaticDataOfEasyStorageClasses();
41099 :
41100 :
41101 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeEllipse );
41102 2 : SgTypeEllipseStorageClass* storageArraySgTypeEllipse = NULL;
41103 2 : if ( 0 < sizeOfActualPool )
41104 : {
41105 4 : storageArraySgTypeEllipse = new SgTypeEllipseStorageClass[sizeOfActualPool] ;
41106 2 : inFile.read ( (char*) (storageArraySgTypeEllipse) , sizeof ( SgTypeEllipseStorageClass ) * sizeOfActualPool) ;
41107 2 : SgTypeEllipseStorageClass :: readEasyStorageDataFromFile(inFile) ;
41108 : SgTypeEllipseStorageClass* storageArray = storageArraySgTypeEllipse;
41109 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41110 : {
41111 2 : SgTypeEllipse* tmp = new SgTypeEllipse ( *storageArray ) ;
41112 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41113 2 : storageArray++ ;
41114 : }
41115 : }
41116 2 : delete [] storageArraySgTypeEllipse;
41117 2 : SgTypeEllipseStorageClass :: deleteStaticDataOfEasyStorageClasses();
41118 :
41119 :
41120 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeFixed );
41121 2 : SgTypeFixedStorageClass* storageArraySgTypeFixed = NULL;
41122 2 : if ( 0 < sizeOfActualPool )
41123 : {
41124 0 : storageArraySgTypeFixed = new SgTypeFixedStorageClass[sizeOfActualPool] ;
41125 0 : inFile.read ( (char*) (storageArraySgTypeFixed) , sizeof ( SgTypeFixedStorageClass ) * sizeOfActualPool) ;
41126 0 : SgTypeFixedStorageClass :: readEasyStorageDataFromFile(inFile) ;
41127 : SgTypeFixedStorageClass* storageArray = storageArraySgTypeFixed;
41128 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41129 : {
41130 0 : SgTypeFixed* tmp = new SgTypeFixed ( *storageArray ) ;
41131 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41132 0 : storageArray++ ;
41133 : }
41134 : }
41135 0 : delete [] storageArraySgTypeFixed;
41136 2 : SgTypeFixedStorageClass :: deleteStaticDataOfEasyStorageClasses();
41137 :
41138 :
41139 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeFloat );
41140 2 : SgTypeFloatStorageClass* storageArraySgTypeFloat = NULL;
41141 2 : if ( 0 < sizeOfActualPool )
41142 : {
41143 4 : storageArraySgTypeFloat = new SgTypeFloatStorageClass[sizeOfActualPool] ;
41144 2 : inFile.read ( (char*) (storageArraySgTypeFloat) , sizeof ( SgTypeFloatStorageClass ) * sizeOfActualPool) ;
41145 2 : SgTypeFloatStorageClass :: readEasyStorageDataFromFile(inFile) ;
41146 : SgTypeFloatStorageClass* storageArray = storageArraySgTypeFloat;
41147 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41148 : {
41149 2 : SgTypeFloat* tmp = new SgTypeFloat ( *storageArray ) ;
41150 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41151 2 : storageArray++ ;
41152 : }
41153 : }
41154 2 : delete [] storageArraySgTypeFloat;
41155 2 : SgTypeFloatStorageClass :: deleteStaticDataOfEasyStorageClasses();
41156 :
41157 :
41158 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeFloat128 );
41159 2 : SgTypeFloat128StorageClass* storageArraySgTypeFloat128 = NULL;
41160 2 : if ( 0 < sizeOfActualPool )
41161 : {
41162 2 : storageArraySgTypeFloat128 = new SgTypeFloat128StorageClass[sizeOfActualPool] ;
41163 1 : inFile.read ( (char*) (storageArraySgTypeFloat128) , sizeof ( SgTypeFloat128StorageClass ) * sizeOfActualPool) ;
41164 1 : SgTypeFloat128StorageClass :: readEasyStorageDataFromFile(inFile) ;
41165 : SgTypeFloat128StorageClass* storageArray = storageArraySgTypeFloat128;
41166 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41167 : {
41168 1 : SgTypeFloat128* tmp = new SgTypeFloat128 ( *storageArray ) ;
41169 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41170 1 : storageArray++ ;
41171 : }
41172 : }
41173 1 : delete [] storageArraySgTypeFloat128;
41174 2 : SgTypeFloat128StorageClass :: deleteStaticDataOfEasyStorageClasses();
41175 :
41176 :
41177 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeFloat80 );
41178 2 : SgTypeFloat80StorageClass* storageArraySgTypeFloat80 = NULL;
41179 2 : if ( 0 < sizeOfActualPool )
41180 : {
41181 0 : storageArraySgTypeFloat80 = new SgTypeFloat80StorageClass[sizeOfActualPool] ;
41182 0 : inFile.read ( (char*) (storageArraySgTypeFloat80) , sizeof ( SgTypeFloat80StorageClass ) * sizeOfActualPool) ;
41183 0 : SgTypeFloat80StorageClass :: readEasyStorageDataFromFile(inFile) ;
41184 : SgTypeFloat80StorageClass* storageArray = storageArraySgTypeFloat80;
41185 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41186 : {
41187 0 : SgTypeFloat80* tmp = new SgTypeFloat80 ( *storageArray ) ;
41188 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41189 0 : storageArray++ ;
41190 : }
41191 : }
41192 0 : delete [] storageArraySgTypeFloat80;
41193 2 : SgTypeFloat80StorageClass :: deleteStaticDataOfEasyStorageClasses();
41194 :
41195 :
41196 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeGlobalVoid );
41197 2 : SgTypeGlobalVoidStorageClass* storageArraySgTypeGlobalVoid = NULL;
41198 2 : if ( 0 < sizeOfActualPool )
41199 : {
41200 0 : storageArraySgTypeGlobalVoid = new SgTypeGlobalVoidStorageClass[sizeOfActualPool] ;
41201 0 : inFile.read ( (char*) (storageArraySgTypeGlobalVoid) , sizeof ( SgTypeGlobalVoidStorageClass ) * sizeOfActualPool) ;
41202 0 : SgTypeGlobalVoidStorageClass :: readEasyStorageDataFromFile(inFile) ;
41203 : SgTypeGlobalVoidStorageClass* storageArray = storageArraySgTypeGlobalVoid;
41204 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41205 : {
41206 0 : SgTypeGlobalVoid* tmp = new SgTypeGlobalVoid ( *storageArray ) ;
41207 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41208 0 : storageArray++ ;
41209 : }
41210 : }
41211 0 : delete [] storageArraySgTypeGlobalVoid;
41212 2 : SgTypeGlobalVoidStorageClass :: deleteStaticDataOfEasyStorageClasses();
41213 :
41214 :
41215 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeIdOp );
41216 2 : SgTypeIdOpStorageClass* storageArraySgTypeIdOp = NULL;
41217 2 : if ( 0 < sizeOfActualPool )
41218 : {
41219 2 : storageArraySgTypeIdOp = new SgTypeIdOpStorageClass[sizeOfActualPool] ;
41220 1 : inFile.read ( (char*) (storageArraySgTypeIdOp) , sizeof ( SgTypeIdOpStorageClass ) * sizeOfActualPool) ;
41221 1 : SgTypeIdOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
41222 : SgTypeIdOpStorageClass* storageArray = storageArraySgTypeIdOp;
41223 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41224 : {
41225 1 : SgTypeIdOp* tmp = new SgTypeIdOp ( *storageArray ) ;
41226 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41227 1 : storageArray++ ;
41228 : }
41229 : }
41230 1 : delete [] storageArraySgTypeIdOp;
41231 2 : SgTypeIdOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
41232 :
41233 :
41234 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeImaginary );
41235 2 : SgTypeImaginaryStorageClass* storageArraySgTypeImaginary = NULL;
41236 2 : if ( 0 < sizeOfActualPool )
41237 : {
41238 0 : storageArraySgTypeImaginary = new SgTypeImaginaryStorageClass[sizeOfActualPool] ;
41239 0 : inFile.read ( (char*) (storageArraySgTypeImaginary) , sizeof ( SgTypeImaginaryStorageClass ) * sizeOfActualPool) ;
41240 0 : SgTypeImaginaryStorageClass :: readEasyStorageDataFromFile(inFile) ;
41241 : SgTypeImaginaryStorageClass* storageArray = storageArraySgTypeImaginary;
41242 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41243 : {
41244 0 : SgTypeImaginary* tmp = new SgTypeImaginary ( *storageArray ) ;
41245 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41246 0 : storageArray++ ;
41247 : }
41248 : }
41249 0 : delete [] storageArraySgTypeImaginary;
41250 2 : SgTypeImaginaryStorageClass :: deleteStaticDataOfEasyStorageClasses();
41251 :
41252 :
41253 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeInt );
41254 2 : SgTypeIntStorageClass* storageArraySgTypeInt = NULL;
41255 2 : if ( 0 < sizeOfActualPool )
41256 : {
41257 4 : storageArraySgTypeInt = new SgTypeIntStorageClass[sizeOfActualPool] ;
41258 2 : inFile.read ( (char*) (storageArraySgTypeInt) , sizeof ( SgTypeIntStorageClass ) * sizeOfActualPool) ;
41259 2 : SgTypeIntStorageClass :: readEasyStorageDataFromFile(inFile) ;
41260 : SgTypeIntStorageClass* storageArray = storageArraySgTypeInt;
41261 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41262 : {
41263 2 : SgTypeInt* tmp = new SgTypeInt ( *storageArray ) ;
41264 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41265 2 : storageArray++ ;
41266 : }
41267 : }
41268 2 : delete [] storageArraySgTypeInt;
41269 2 : SgTypeIntStorageClass :: deleteStaticDataOfEasyStorageClasses();
41270 :
41271 :
41272 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeLong );
41273 2 : SgTypeLongStorageClass* storageArraySgTypeLong = NULL;
41274 2 : if ( 0 < sizeOfActualPool )
41275 : {
41276 4 : storageArraySgTypeLong = new SgTypeLongStorageClass[sizeOfActualPool] ;
41277 2 : inFile.read ( (char*) (storageArraySgTypeLong) , sizeof ( SgTypeLongStorageClass ) * sizeOfActualPool) ;
41278 2 : SgTypeLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41279 : SgTypeLongStorageClass* storageArray = storageArraySgTypeLong;
41280 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41281 : {
41282 2 : SgTypeLong* tmp = new SgTypeLong ( *storageArray ) ;
41283 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41284 2 : storageArray++ ;
41285 : }
41286 : }
41287 2 : delete [] storageArraySgTypeLong;
41288 2 : SgTypeLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41289 :
41290 :
41291 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeLongDouble );
41292 2 : SgTypeLongDoubleStorageClass* storageArraySgTypeLongDouble = NULL;
41293 2 : if ( 0 < sizeOfActualPool )
41294 : {
41295 4 : storageArraySgTypeLongDouble = new SgTypeLongDoubleStorageClass[sizeOfActualPool] ;
41296 2 : inFile.read ( (char*) (storageArraySgTypeLongDouble) , sizeof ( SgTypeLongDoubleStorageClass ) * sizeOfActualPool) ;
41297 2 : SgTypeLongDoubleStorageClass :: readEasyStorageDataFromFile(inFile) ;
41298 : SgTypeLongDoubleStorageClass* storageArray = storageArraySgTypeLongDouble;
41299 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41300 : {
41301 2 : SgTypeLongDouble* tmp = new SgTypeLongDouble ( *storageArray ) ;
41302 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41303 2 : storageArray++ ;
41304 : }
41305 : }
41306 2 : delete [] storageArraySgTypeLongDouble;
41307 2 : SgTypeLongDoubleStorageClass :: deleteStaticDataOfEasyStorageClasses();
41308 :
41309 :
41310 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeLongLong );
41311 2 : SgTypeLongLongStorageClass* storageArraySgTypeLongLong = NULL;
41312 2 : if ( 0 < sizeOfActualPool )
41313 : {
41314 4 : storageArraySgTypeLongLong = new SgTypeLongLongStorageClass[sizeOfActualPool] ;
41315 2 : inFile.read ( (char*) (storageArraySgTypeLongLong) , sizeof ( SgTypeLongLongStorageClass ) * sizeOfActualPool) ;
41316 2 : SgTypeLongLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41317 : SgTypeLongLongStorageClass* storageArray = storageArraySgTypeLongLong;
41318 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41319 : {
41320 2 : SgTypeLongLong* tmp = new SgTypeLongLong ( *storageArray ) ;
41321 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41322 2 : storageArray++ ;
41323 : }
41324 : }
41325 2 : delete [] storageArraySgTypeLongLong;
41326 2 : SgTypeLongLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41327 :
41328 :
41329 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeModifier );
41330 2 : SgTypeModifierStorageClass* storageArraySgTypeModifier = NULL;
41331 2 : if ( 0 < sizeOfActualPool )
41332 : {
41333 0 : storageArraySgTypeModifier = new SgTypeModifierStorageClass[sizeOfActualPool] ;
41334 0 : inFile.read ( (char*) (storageArraySgTypeModifier) , sizeof ( SgTypeModifierStorageClass ) * sizeOfActualPool) ;
41335 0 : SgTypeModifierStorageClass :: readEasyStorageDataFromFile(inFile) ;
41336 : SgTypeModifierStorageClass* storageArray = storageArraySgTypeModifier;
41337 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41338 : {
41339 0 : SgTypeModifier* tmp = new SgTypeModifier ( *storageArray ) ;
41340 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41341 0 : storageArray++ ;
41342 : }
41343 : }
41344 0 : delete [] storageArraySgTypeModifier;
41345 2 : SgTypeModifierStorageClass :: deleteStaticDataOfEasyStorageClasses();
41346 :
41347 :
41348 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeMatrix );
41349 2 : SgTypeMatrixStorageClass* storageArraySgTypeMatrix = NULL;
41350 2 : if ( 0 < sizeOfActualPool )
41351 : {
41352 0 : storageArraySgTypeMatrix = new SgTypeMatrixStorageClass[sizeOfActualPool] ;
41353 0 : inFile.read ( (char*) (storageArraySgTypeMatrix) , sizeof ( SgTypeMatrixStorageClass ) * sizeOfActualPool) ;
41354 0 : SgTypeMatrixStorageClass :: readEasyStorageDataFromFile(inFile) ;
41355 : SgTypeMatrixStorageClass* storageArray = storageArraySgTypeMatrix;
41356 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41357 : {
41358 0 : SgTypeMatrix* tmp = new SgTypeMatrix ( *storageArray ) ;
41359 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41360 0 : storageArray++ ;
41361 : }
41362 : }
41363 0 : delete [] storageArraySgTypeMatrix;
41364 2 : SgTypeMatrixStorageClass :: deleteStaticDataOfEasyStorageClasses();
41365 :
41366 :
41367 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeTuple );
41368 2 : SgTypeTupleStorageClass* storageArraySgTypeTuple = NULL;
41369 2 : if ( 0 < sizeOfActualPool )
41370 : {
41371 0 : storageArraySgTypeTuple = new SgTypeTupleStorageClass[sizeOfActualPool] ;
41372 0 : inFile.read ( (char*) (storageArraySgTypeTuple) , sizeof ( SgTypeTupleStorageClass ) * sizeOfActualPool) ;
41373 0 : SgTypeTupleStorageClass :: readEasyStorageDataFromFile(inFile) ;
41374 : SgTypeTupleStorageClass* storageArray = storageArraySgTypeTuple;
41375 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41376 : {
41377 0 : SgTypeTuple* tmp = new SgTypeTuple ( *storageArray ) ;
41378 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41379 0 : storageArray++ ;
41380 : }
41381 : }
41382 0 : delete [] storageArraySgTypeTuple;
41383 2 : SgTypeTupleStorageClass :: deleteStaticDataOfEasyStorageClasses();
41384 :
41385 :
41386 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeNullptr );
41387 2 : SgTypeNullptrStorageClass* storageArraySgTypeNullptr = NULL;
41388 2 : if ( 0 < sizeOfActualPool )
41389 : {
41390 2 : storageArraySgTypeNullptr = new SgTypeNullptrStorageClass[sizeOfActualPool] ;
41391 1 : inFile.read ( (char*) (storageArraySgTypeNullptr) , sizeof ( SgTypeNullptrStorageClass ) * sizeOfActualPool) ;
41392 1 : SgTypeNullptrStorageClass :: readEasyStorageDataFromFile(inFile) ;
41393 : SgTypeNullptrStorageClass* storageArray = storageArraySgTypeNullptr;
41394 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41395 : {
41396 1 : SgTypeNullptr* tmp = new SgTypeNullptr ( *storageArray ) ;
41397 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41398 1 : storageArray++ ;
41399 : }
41400 : }
41401 1 : delete [] storageArraySgTypeNullptr;
41402 2 : SgTypeNullptrStorageClass :: deleteStaticDataOfEasyStorageClasses();
41403 :
41404 :
41405 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeOfType );
41406 2 : SgTypeOfTypeStorageClass* storageArraySgTypeOfType = NULL;
41407 2 : if ( 0 < sizeOfActualPool )
41408 : {
41409 4 : storageArraySgTypeOfType = new SgTypeOfTypeStorageClass[sizeOfActualPool] ;
41410 1 : inFile.read ( (char*) (storageArraySgTypeOfType) , sizeof ( SgTypeOfTypeStorageClass ) * sizeOfActualPool) ;
41411 1 : SgTypeOfTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
41412 : SgTypeOfTypeStorageClass* storageArray = storageArraySgTypeOfType;
41413 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41414 : {
41415 3 : SgTypeOfType* tmp = new SgTypeOfType ( *storageArray ) ;
41416 3 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41417 3 : storageArray++ ;
41418 : }
41419 : }
41420 1 : delete [] storageArraySgTypeOfType;
41421 2 : SgTypeOfTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
41422 :
41423 :
41424 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeShort );
41425 2 : SgTypeShortStorageClass* storageArraySgTypeShort = NULL;
41426 2 : if ( 0 < sizeOfActualPool )
41427 : {
41428 4 : storageArraySgTypeShort = new SgTypeShortStorageClass[sizeOfActualPool] ;
41429 2 : inFile.read ( (char*) (storageArraySgTypeShort) , sizeof ( SgTypeShortStorageClass ) * sizeOfActualPool) ;
41430 2 : SgTypeShortStorageClass :: readEasyStorageDataFromFile(inFile) ;
41431 : SgTypeShortStorageClass* storageArray = storageArraySgTypeShort;
41432 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41433 : {
41434 2 : SgTypeShort* tmp = new SgTypeShort ( *storageArray ) ;
41435 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41436 2 : storageArray++ ;
41437 : }
41438 : }
41439 2 : delete [] storageArraySgTypeShort;
41440 2 : SgTypeShortStorageClass :: deleteStaticDataOfEasyStorageClasses();
41441 :
41442 :
41443 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSigned128bitInteger );
41444 2 : SgTypeSigned128bitIntegerStorageClass* storageArraySgTypeSigned128bitInteger = NULL;
41445 2 : if ( 0 < sizeOfActualPool )
41446 : {
41447 2 : storageArraySgTypeSigned128bitInteger = new SgTypeSigned128bitIntegerStorageClass[sizeOfActualPool] ;
41448 1 : inFile.read ( (char*) (storageArraySgTypeSigned128bitInteger) , sizeof ( SgTypeSigned128bitIntegerStorageClass ) * sizeOfActualPool) ;
41449 1 : SgTypeSigned128bitIntegerStorageClass :: readEasyStorageDataFromFile(inFile) ;
41450 : SgTypeSigned128bitIntegerStorageClass* storageArray = storageArraySgTypeSigned128bitInteger;
41451 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41452 : {
41453 1 : SgTypeSigned128bitInteger* tmp = new SgTypeSigned128bitInteger ( *storageArray ) ;
41454 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41455 1 : storageArray++ ;
41456 : }
41457 : }
41458 1 : delete [] storageArraySgTypeSigned128bitInteger;
41459 2 : SgTypeSigned128bitIntegerStorageClass :: deleteStaticDataOfEasyStorageClasses();
41460 :
41461 :
41462 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSignedChar );
41463 2 : SgTypeSignedCharStorageClass* storageArraySgTypeSignedChar = NULL;
41464 2 : if ( 0 < sizeOfActualPool )
41465 : {
41466 4 : storageArraySgTypeSignedChar = new SgTypeSignedCharStorageClass[sizeOfActualPool] ;
41467 2 : inFile.read ( (char*) (storageArraySgTypeSignedChar) , sizeof ( SgTypeSignedCharStorageClass ) * sizeOfActualPool) ;
41468 2 : SgTypeSignedCharStorageClass :: readEasyStorageDataFromFile(inFile) ;
41469 : SgTypeSignedCharStorageClass* storageArray = storageArraySgTypeSignedChar;
41470 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41471 : {
41472 2 : SgTypeSignedChar* tmp = new SgTypeSignedChar ( *storageArray ) ;
41473 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41474 2 : storageArray++ ;
41475 : }
41476 : }
41477 2 : delete [] storageArraySgTypeSignedChar;
41478 2 : SgTypeSignedCharStorageClass :: deleteStaticDataOfEasyStorageClasses();
41479 :
41480 :
41481 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSignedInt );
41482 2 : SgTypeSignedIntStorageClass* storageArraySgTypeSignedInt = NULL;
41483 2 : if ( 0 < sizeOfActualPool )
41484 : {
41485 4 : storageArraySgTypeSignedInt = new SgTypeSignedIntStorageClass[sizeOfActualPool] ;
41486 2 : inFile.read ( (char*) (storageArraySgTypeSignedInt) , sizeof ( SgTypeSignedIntStorageClass ) * sizeOfActualPool) ;
41487 2 : SgTypeSignedIntStorageClass :: readEasyStorageDataFromFile(inFile) ;
41488 : SgTypeSignedIntStorageClass* storageArray = storageArraySgTypeSignedInt;
41489 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41490 : {
41491 2 : SgTypeSignedInt* tmp = new SgTypeSignedInt ( *storageArray ) ;
41492 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41493 2 : storageArray++ ;
41494 : }
41495 : }
41496 2 : delete [] storageArraySgTypeSignedInt;
41497 2 : SgTypeSignedIntStorageClass :: deleteStaticDataOfEasyStorageClasses();
41498 :
41499 :
41500 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSignedLong );
41501 2 : SgTypeSignedLongStorageClass* storageArraySgTypeSignedLong = NULL;
41502 2 : if ( 0 < sizeOfActualPool )
41503 : {
41504 4 : storageArraySgTypeSignedLong = new SgTypeSignedLongStorageClass[sizeOfActualPool] ;
41505 2 : inFile.read ( (char*) (storageArraySgTypeSignedLong) , sizeof ( SgTypeSignedLongStorageClass ) * sizeOfActualPool) ;
41506 2 : SgTypeSignedLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41507 : SgTypeSignedLongStorageClass* storageArray = storageArraySgTypeSignedLong;
41508 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41509 : {
41510 2 : SgTypeSignedLong* tmp = new SgTypeSignedLong ( *storageArray ) ;
41511 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41512 2 : storageArray++ ;
41513 : }
41514 : }
41515 2 : delete [] storageArraySgTypeSignedLong;
41516 2 : SgTypeSignedLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41517 :
41518 :
41519 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSignedLongLong );
41520 2 : SgTypeSignedLongLongStorageClass* storageArraySgTypeSignedLongLong = NULL;
41521 2 : if ( 0 < sizeOfActualPool )
41522 : {
41523 2 : storageArraySgTypeSignedLongLong = new SgTypeSignedLongLongStorageClass[sizeOfActualPool] ;
41524 1 : inFile.read ( (char*) (storageArraySgTypeSignedLongLong) , sizeof ( SgTypeSignedLongLongStorageClass ) * sizeOfActualPool) ;
41525 1 : SgTypeSignedLongLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41526 : SgTypeSignedLongLongStorageClass* storageArray = storageArraySgTypeSignedLongLong;
41527 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41528 : {
41529 1 : SgTypeSignedLongLong* tmp = new SgTypeSignedLongLong ( *storageArray ) ;
41530 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41531 1 : storageArray++ ;
41532 : }
41533 : }
41534 1 : delete [] storageArraySgTypeSignedLongLong;
41535 2 : SgTypeSignedLongLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41536 :
41537 :
41538 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeSignedShort );
41539 2 : SgTypeSignedShortStorageClass* storageArraySgTypeSignedShort = NULL;
41540 2 : if ( 0 < sizeOfActualPool )
41541 : {
41542 4 : storageArraySgTypeSignedShort = new SgTypeSignedShortStorageClass[sizeOfActualPool] ;
41543 2 : inFile.read ( (char*) (storageArraySgTypeSignedShort) , sizeof ( SgTypeSignedShortStorageClass ) * sizeOfActualPool) ;
41544 2 : SgTypeSignedShortStorageClass :: readEasyStorageDataFromFile(inFile) ;
41545 : SgTypeSignedShortStorageClass* storageArray = storageArraySgTypeSignedShort;
41546 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41547 : {
41548 2 : SgTypeSignedShort* tmp = new SgTypeSignedShort ( *storageArray ) ;
41549 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41550 2 : storageArray++ ;
41551 : }
41552 : }
41553 2 : delete [] storageArraySgTypeSignedShort;
41554 2 : SgTypeSignedShortStorageClass :: deleteStaticDataOfEasyStorageClasses();
41555 :
41556 :
41557 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeString );
41558 2 : SgTypeStringStorageClass* storageArraySgTypeString = NULL;
41559 2 : if ( 0 < sizeOfActualPool )
41560 : {
41561 0 : storageArraySgTypeString = new SgTypeStringStorageClass[sizeOfActualPool] ;
41562 0 : inFile.read ( (char*) (storageArraySgTypeString) , sizeof ( SgTypeStringStorageClass ) * sizeOfActualPool) ;
41563 0 : SgTypeStringStorageClass :: readEasyStorageDataFromFile(inFile) ;
41564 : SgTypeStringStorageClass* storageArray = storageArraySgTypeString;
41565 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41566 : {
41567 0 : SgTypeString* tmp = new SgTypeString ( *storageArray ) ;
41568 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41569 0 : storageArray++ ;
41570 : }
41571 : }
41572 0 : delete [] storageArraySgTypeString;
41573 2 : SgTypeStringStorageClass :: deleteStaticDataOfEasyStorageClasses();
41574 :
41575 :
41576 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnknown );
41577 2 : SgTypeUnknownStorageClass* storageArraySgTypeUnknown = NULL;
41578 2 : if ( 0 < sizeOfActualPool )
41579 : {
41580 2 : storageArraySgTypeUnknown = new SgTypeUnknownStorageClass[sizeOfActualPool] ;
41581 1 : inFile.read ( (char*) (storageArraySgTypeUnknown) , sizeof ( SgTypeUnknownStorageClass ) * sizeOfActualPool) ;
41582 1 : SgTypeUnknownStorageClass :: readEasyStorageDataFromFile(inFile) ;
41583 : SgTypeUnknownStorageClass* storageArray = storageArraySgTypeUnknown;
41584 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41585 : {
41586 1 : SgTypeUnknown* tmp = new SgTypeUnknown ( *storageArray ) ;
41587 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41588 1 : storageArray++ ;
41589 : }
41590 : }
41591 1 : delete [] storageArraySgTypeUnknown;
41592 2 : SgTypeUnknownStorageClass :: deleteStaticDataOfEasyStorageClasses();
41593 :
41594 :
41595 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsigned128bitInteger );
41596 2 : SgTypeUnsigned128bitIntegerStorageClass* storageArraySgTypeUnsigned128bitInteger = NULL;
41597 2 : if ( 0 < sizeOfActualPool )
41598 : {
41599 2 : storageArraySgTypeUnsigned128bitInteger = new SgTypeUnsigned128bitIntegerStorageClass[sizeOfActualPool] ;
41600 1 : inFile.read ( (char*) (storageArraySgTypeUnsigned128bitInteger) , sizeof ( SgTypeUnsigned128bitIntegerStorageClass ) * sizeOfActualPool) ;
41601 1 : SgTypeUnsigned128bitIntegerStorageClass :: readEasyStorageDataFromFile(inFile) ;
41602 : SgTypeUnsigned128bitIntegerStorageClass* storageArray = storageArraySgTypeUnsigned128bitInteger;
41603 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41604 : {
41605 1 : SgTypeUnsigned128bitInteger* tmp = new SgTypeUnsigned128bitInteger ( *storageArray ) ;
41606 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41607 1 : storageArray++ ;
41608 : }
41609 : }
41610 1 : delete [] storageArraySgTypeUnsigned128bitInteger;
41611 2 : SgTypeUnsigned128bitIntegerStorageClass :: deleteStaticDataOfEasyStorageClasses();
41612 :
41613 :
41614 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsignedChar );
41615 2 : SgTypeUnsignedCharStorageClass* storageArraySgTypeUnsignedChar = NULL;
41616 2 : if ( 0 < sizeOfActualPool )
41617 : {
41618 4 : storageArraySgTypeUnsignedChar = new SgTypeUnsignedCharStorageClass[sizeOfActualPool] ;
41619 2 : inFile.read ( (char*) (storageArraySgTypeUnsignedChar) , sizeof ( SgTypeUnsignedCharStorageClass ) * sizeOfActualPool) ;
41620 2 : SgTypeUnsignedCharStorageClass :: readEasyStorageDataFromFile(inFile) ;
41621 : SgTypeUnsignedCharStorageClass* storageArray = storageArraySgTypeUnsignedChar;
41622 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41623 : {
41624 2 : SgTypeUnsignedChar* tmp = new SgTypeUnsignedChar ( *storageArray ) ;
41625 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41626 2 : storageArray++ ;
41627 : }
41628 : }
41629 2 : delete [] storageArraySgTypeUnsignedChar;
41630 2 : SgTypeUnsignedCharStorageClass :: deleteStaticDataOfEasyStorageClasses();
41631 :
41632 :
41633 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsignedInt );
41634 2 : SgTypeUnsignedIntStorageClass* storageArraySgTypeUnsignedInt = NULL;
41635 2 : if ( 0 < sizeOfActualPool )
41636 : {
41637 4 : storageArraySgTypeUnsignedInt = new SgTypeUnsignedIntStorageClass[sizeOfActualPool] ;
41638 2 : inFile.read ( (char*) (storageArraySgTypeUnsignedInt) , sizeof ( SgTypeUnsignedIntStorageClass ) * sizeOfActualPool) ;
41639 2 : SgTypeUnsignedIntStorageClass :: readEasyStorageDataFromFile(inFile) ;
41640 : SgTypeUnsignedIntStorageClass* storageArray = storageArraySgTypeUnsignedInt;
41641 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41642 : {
41643 2 : SgTypeUnsignedInt* tmp = new SgTypeUnsignedInt ( *storageArray ) ;
41644 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41645 2 : storageArray++ ;
41646 : }
41647 : }
41648 2 : delete [] storageArraySgTypeUnsignedInt;
41649 2 : SgTypeUnsignedIntStorageClass :: deleteStaticDataOfEasyStorageClasses();
41650 :
41651 :
41652 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsignedLong );
41653 2 : SgTypeUnsignedLongStorageClass* storageArraySgTypeUnsignedLong = NULL;
41654 2 : if ( 0 < sizeOfActualPool )
41655 : {
41656 4 : storageArraySgTypeUnsignedLong = new SgTypeUnsignedLongStorageClass[sizeOfActualPool] ;
41657 2 : inFile.read ( (char*) (storageArraySgTypeUnsignedLong) , sizeof ( SgTypeUnsignedLongStorageClass ) * sizeOfActualPool) ;
41658 2 : SgTypeUnsignedLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41659 : SgTypeUnsignedLongStorageClass* storageArray = storageArraySgTypeUnsignedLong;
41660 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41661 : {
41662 2 : SgTypeUnsignedLong* tmp = new SgTypeUnsignedLong ( *storageArray ) ;
41663 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41664 2 : storageArray++ ;
41665 : }
41666 : }
41667 2 : delete [] storageArraySgTypeUnsignedLong;
41668 2 : SgTypeUnsignedLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41669 :
41670 :
41671 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsignedLongLong );
41672 2 : SgTypeUnsignedLongLongStorageClass* storageArraySgTypeUnsignedLongLong = NULL;
41673 2 : if ( 0 < sizeOfActualPool )
41674 : {
41675 4 : storageArraySgTypeUnsignedLongLong = new SgTypeUnsignedLongLongStorageClass[sizeOfActualPool] ;
41676 2 : inFile.read ( (char*) (storageArraySgTypeUnsignedLongLong) , sizeof ( SgTypeUnsignedLongLongStorageClass ) * sizeOfActualPool) ;
41677 2 : SgTypeUnsignedLongLongStorageClass :: readEasyStorageDataFromFile(inFile) ;
41678 : SgTypeUnsignedLongLongStorageClass* storageArray = storageArraySgTypeUnsignedLongLong;
41679 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41680 : {
41681 2 : SgTypeUnsignedLongLong* tmp = new SgTypeUnsignedLongLong ( *storageArray ) ;
41682 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41683 2 : storageArray++ ;
41684 : }
41685 : }
41686 2 : delete [] storageArraySgTypeUnsignedLongLong;
41687 2 : SgTypeUnsignedLongLongStorageClass :: deleteStaticDataOfEasyStorageClasses();
41688 :
41689 :
41690 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeUnsignedShort );
41691 2 : SgTypeUnsignedShortStorageClass* storageArraySgTypeUnsignedShort = NULL;
41692 2 : if ( 0 < sizeOfActualPool )
41693 : {
41694 4 : storageArraySgTypeUnsignedShort = new SgTypeUnsignedShortStorageClass[sizeOfActualPool] ;
41695 2 : inFile.read ( (char*) (storageArraySgTypeUnsignedShort) , sizeof ( SgTypeUnsignedShortStorageClass ) * sizeOfActualPool) ;
41696 2 : SgTypeUnsignedShortStorageClass :: readEasyStorageDataFromFile(inFile) ;
41697 : SgTypeUnsignedShortStorageClass* storageArray = storageArraySgTypeUnsignedShort;
41698 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41699 : {
41700 2 : SgTypeUnsignedShort* tmp = new SgTypeUnsignedShort ( *storageArray ) ;
41701 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41702 2 : storageArray++ ;
41703 : }
41704 : }
41705 2 : delete [] storageArraySgTypeUnsignedShort;
41706 2 : SgTypeUnsignedShortStorageClass :: deleteStaticDataOfEasyStorageClasses();
41707 :
41708 :
41709 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeVoid );
41710 2 : SgTypeVoidStorageClass* storageArraySgTypeVoid = NULL;
41711 2 : if ( 0 < sizeOfActualPool )
41712 : {
41713 4 : storageArraySgTypeVoid = new SgTypeVoidStorageClass[sizeOfActualPool] ;
41714 2 : inFile.read ( (char*) (storageArraySgTypeVoid) , sizeof ( SgTypeVoidStorageClass ) * sizeOfActualPool) ;
41715 2 : SgTypeVoidStorageClass :: readEasyStorageDataFromFile(inFile) ;
41716 : SgTypeVoidStorageClass* storageArray = storageArraySgTypeVoid;
41717 4 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41718 : {
41719 2 : SgTypeVoid* tmp = new SgTypeVoid ( *storageArray ) ;
41720 2 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41721 2 : storageArray++ ;
41722 : }
41723 : }
41724 2 : delete [] storageArraySgTypeVoid;
41725 2 : SgTypeVoidStorageClass :: deleteStaticDataOfEasyStorageClasses();
41726 :
41727 :
41728 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeWchar );
41729 2 : SgTypeWcharStorageClass* storageArraySgTypeWchar = NULL;
41730 2 : if ( 0 < sizeOfActualPool )
41731 : {
41732 2 : storageArraySgTypeWchar = new SgTypeWcharStorageClass[sizeOfActualPool] ;
41733 1 : inFile.read ( (char*) (storageArraySgTypeWchar) , sizeof ( SgTypeWcharStorageClass ) * sizeOfActualPool) ;
41734 1 : SgTypeWcharStorageClass :: readEasyStorageDataFromFile(inFile) ;
41735 : SgTypeWcharStorageClass* storageArray = storageArraySgTypeWchar;
41736 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41737 : {
41738 1 : SgTypeWchar* tmp = new SgTypeWchar ( *storageArray ) ;
41739 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41740 1 : storageArray++ ;
41741 : }
41742 : }
41743 1 : delete [] storageArraySgTypeWchar;
41744 2 : SgTypeWcharStorageClass :: deleteStaticDataOfEasyStorageClasses();
41745 :
41746 :
41747 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypedefDeclaration );
41748 2 : SgTypedefDeclarationStorageClass* storageArraySgTypedefDeclaration = NULL;
41749 2 : if ( 0 < sizeOfActualPool )
41750 : {
41751 1721 : storageArraySgTypedefDeclaration = new SgTypedefDeclarationStorageClass[sizeOfActualPool] ;
41752 2 : inFile.read ( (char*) (storageArraySgTypedefDeclaration) , sizeof ( SgTypedefDeclarationStorageClass ) * sizeOfActualPool) ;
41753 2 : SgTypedefDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
41754 : SgTypedefDeclarationStorageClass* storageArray = storageArraySgTypedefDeclaration;
41755 1721 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41756 : {
41757 1719 : SgTypedefDeclaration* tmp = new SgTypedefDeclaration ( *storageArray ) ;
41758 1719 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41759 1719 : storageArray++ ;
41760 : }
41761 : }
41762 2 : delete [] storageArraySgTypedefDeclaration;
41763 2 : SgTypedefDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
41764 :
41765 :
41766 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypedefSeq );
41767 2 : SgTypedefSeqStorageClass* storageArraySgTypedefSeq = NULL;
41768 2 : if ( 0 < sizeOfActualPool )
41769 : {
41770 16447 : storageArraySgTypedefSeq = new SgTypedefSeqStorageClass[sizeOfActualPool] ;
41771 2 : inFile.read ( (char*) (storageArraySgTypedefSeq) , sizeof ( SgTypedefSeqStorageClass ) * sizeOfActualPool) ;
41772 2 : SgTypedefSeqStorageClass :: readEasyStorageDataFromFile(inFile) ;
41773 : SgTypedefSeqStorageClass* storageArray = storageArraySgTypedefSeq;
41774 16447 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41775 : {
41776 16445 : SgTypedefSeq* tmp = new SgTypedefSeq ( *storageArray ) ;
41777 16445 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41778 16445 : storageArray++ ;
41779 : }
41780 : }
41781 2 : delete [] storageArraySgTypedefSeq;
41782 2 : SgTypedefSeqStorageClass :: deleteStaticDataOfEasyStorageClasses();
41783 :
41784 :
41785 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypedefSymbol );
41786 2 : SgTypedefSymbolStorageClass* storageArraySgTypedefSymbol = NULL;
41787 2 : if ( 0 < sizeOfActualPool )
41788 : {
41789 1721 : storageArraySgTypedefSymbol = new SgTypedefSymbolStorageClass[sizeOfActualPool] ;
41790 2 : inFile.read ( (char*) (storageArraySgTypedefSymbol) , sizeof ( SgTypedefSymbolStorageClass ) * sizeOfActualPool) ;
41791 2 : SgTypedefSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
41792 : SgTypedefSymbolStorageClass* storageArray = storageArraySgTypedefSymbol;
41793 1721 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41794 : {
41795 1719 : SgTypedefSymbol* tmp = new SgTypedefSymbol ( *storageArray ) ;
41796 1719 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41797 1719 : storageArray++ ;
41798 : }
41799 : }
41800 2 : delete [] storageArraySgTypedefSymbol;
41801 2 : SgTypedefSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
41802 :
41803 :
41804 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypedefType );
41805 2 : SgTypedefTypeStorageClass* storageArraySgTypedefType = NULL;
41806 2 : if ( 0 < sizeOfActualPool )
41807 : {
41808 1850 : storageArraySgTypedefType = new SgTypedefTypeStorageClass[sizeOfActualPool] ;
41809 2 : inFile.read ( (char*) (storageArraySgTypedefType) , sizeof ( SgTypedefTypeStorageClass ) * sizeOfActualPool) ;
41810 2 : SgTypedefTypeStorageClass :: readEasyStorageDataFromFile(inFile) ;
41811 : SgTypedefTypeStorageClass* storageArray = storageArraySgTypedefType;
41812 1850 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41813 : {
41814 1848 : SgTypedefType* tmp = new SgTypedefType ( *storageArray ) ;
41815 1848 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41816 1848 : storageArray++ ;
41817 : }
41818 : }
41819 2 : delete [] storageArraySgTypedefType;
41820 2 : SgTypedefTypeStorageClass :: deleteStaticDataOfEasyStorageClasses();
41821 :
41822 :
41823 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUPC_AccessModifier );
41824 2 : SgUPC_AccessModifierStorageClass* storageArraySgUPC_AccessModifier = NULL;
41825 2 : if ( 0 < sizeOfActualPool )
41826 : {
41827 0 : storageArraySgUPC_AccessModifier = new SgUPC_AccessModifierStorageClass[sizeOfActualPool] ;
41828 0 : inFile.read ( (char*) (storageArraySgUPC_AccessModifier) , sizeof ( SgUPC_AccessModifierStorageClass ) * sizeOfActualPool) ;
41829 : SgUPC_AccessModifierStorageClass* storageArray = storageArraySgUPC_AccessModifier;
41830 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41831 : {
41832 0 : SgUPC_AccessModifier* tmp = new SgUPC_AccessModifier ( *storageArray ) ;
41833 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41834 0 : storageArray++ ;
41835 : }
41836 : }
41837 0 : delete [] storageArraySgUPC_AccessModifier;
41838 :
41839 :
41840 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnaryAddOp );
41841 2 : SgUnaryAddOpStorageClass* storageArraySgUnaryAddOp = NULL;
41842 2 : if ( 0 < sizeOfActualPool )
41843 : {
41844 0 : storageArraySgUnaryAddOp = new SgUnaryAddOpStorageClass[sizeOfActualPool] ;
41845 0 : inFile.read ( (char*) (storageArraySgUnaryAddOp) , sizeof ( SgUnaryAddOpStorageClass ) * sizeOfActualPool) ;
41846 0 : SgUnaryAddOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
41847 : SgUnaryAddOpStorageClass* storageArray = storageArraySgUnaryAddOp;
41848 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41849 : {
41850 0 : SgUnaryAddOp* tmp = new SgUnaryAddOp ( *storageArray ) ;
41851 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41852 0 : storageArray++ ;
41853 : }
41854 : }
41855 0 : delete [] storageArraySgUnaryAddOp;
41856 2 : SgUnaryAddOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
41857 :
41858 :
41859 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnaryOp );
41860 2 : SgUnaryOpStorageClass* storageArraySgUnaryOp = NULL;
41861 2 : if ( 0 < sizeOfActualPool )
41862 : {
41863 0 : storageArraySgUnaryOp = new SgUnaryOpStorageClass[sizeOfActualPool] ;
41864 0 : inFile.read ( (char*) (storageArraySgUnaryOp) , sizeof ( SgUnaryOpStorageClass ) * sizeOfActualPool) ;
41865 0 : SgUnaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
41866 : SgUnaryOpStorageClass* storageArray = storageArraySgUnaryOp;
41867 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41868 : {
41869 0 : SgUnaryOp* tmp = new SgUnaryOp ( *storageArray ) ;
41870 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41871 0 : storageArray++ ;
41872 : }
41873 : }
41874 0 : delete [] storageArraySgUnaryOp;
41875 2 : SgUnaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
41876 :
41877 :
41878 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUndefDirectiveStatement );
41879 2 : SgUndefDirectiveStatementStorageClass* storageArraySgUndefDirectiveStatement = NULL;
41880 2 : if ( 0 < sizeOfActualPool )
41881 : {
41882 0 : storageArraySgUndefDirectiveStatement = new SgUndefDirectiveStatementStorageClass[sizeOfActualPool] ;
41883 0 : inFile.read ( (char*) (storageArraySgUndefDirectiveStatement) , sizeof ( SgUndefDirectiveStatementStorageClass ) * sizeOfActualPool) ;
41884 0 : SgUndefDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
41885 : SgUndefDirectiveStatementStorageClass* storageArray = storageArraySgUndefDirectiveStatement;
41886 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41887 : {
41888 0 : SgUndefDirectiveStatement* tmp = new SgUndefDirectiveStatement ( *storageArray ) ;
41889 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41890 0 : storageArray++ ;
41891 : }
41892 : }
41893 0 : delete [] storageArraySgUndefDirectiveStatement;
41894 2 : SgUndefDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
41895 :
41896 :
41897 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUndirectedGraphEdge );
41898 2 : SgUndirectedGraphEdgeStorageClass* storageArraySgUndirectedGraphEdge = NULL;
41899 2 : if ( 0 < sizeOfActualPool )
41900 : {
41901 0 : storageArraySgUndirectedGraphEdge = new SgUndirectedGraphEdgeStorageClass[sizeOfActualPool] ;
41902 0 : inFile.read ( (char*) (storageArraySgUndirectedGraphEdge) , sizeof ( SgUndirectedGraphEdgeStorageClass ) * sizeOfActualPool) ;
41903 0 : SgUndirectedGraphEdgeStorageClass :: readEasyStorageDataFromFile(inFile) ;
41904 : SgUndirectedGraphEdgeStorageClass* storageArray = storageArraySgUndirectedGraphEdge;
41905 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41906 : {
41907 0 : SgUndirectedGraphEdge* tmp = new SgUndirectedGraphEdge ( *storageArray ) ;
41908 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41909 0 : storageArray++ ;
41910 : }
41911 : }
41912 0 : delete [] storageArraySgUndirectedGraphEdge;
41913 2 : SgUndirectedGraphEdgeStorageClass :: deleteStaticDataOfEasyStorageClasses();
41914 :
41915 :
41916 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnknownArrayOrFunctionReference );
41917 2 : SgUnknownArrayOrFunctionReferenceStorageClass* storageArraySgUnknownArrayOrFunctionReference = NULL;
41918 2 : if ( 0 < sizeOfActualPool )
41919 : {
41920 0 : storageArraySgUnknownArrayOrFunctionReference = new SgUnknownArrayOrFunctionReferenceStorageClass[sizeOfActualPool] ;
41921 0 : inFile.read ( (char*) (storageArraySgUnknownArrayOrFunctionReference) , sizeof ( SgUnknownArrayOrFunctionReferenceStorageClass ) * sizeOfActualPool) ;
41922 0 : SgUnknownArrayOrFunctionReferenceStorageClass :: readEasyStorageDataFromFile(inFile) ;
41923 : SgUnknownArrayOrFunctionReferenceStorageClass* storageArray = storageArraySgUnknownArrayOrFunctionReference;
41924 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41925 : {
41926 0 : SgUnknownArrayOrFunctionReference* tmp = new SgUnknownArrayOrFunctionReference ( *storageArray ) ;
41927 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41928 0 : storageArray++ ;
41929 : }
41930 : }
41931 0 : delete [] storageArraySgUnknownArrayOrFunctionReference;
41932 2 : SgUnknownArrayOrFunctionReferenceStorageClass :: deleteStaticDataOfEasyStorageClasses();
41933 :
41934 :
41935 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnknownFile );
41936 2 : SgUnknownFileStorageClass* storageArraySgUnknownFile = NULL;
41937 2 : if ( 0 < sizeOfActualPool )
41938 : {
41939 0 : storageArraySgUnknownFile = new SgUnknownFileStorageClass[sizeOfActualPool] ;
41940 0 : inFile.read ( (char*) (storageArraySgUnknownFile) , sizeof ( SgUnknownFileStorageClass ) * sizeOfActualPool) ;
41941 0 : SgUnknownFileStorageClass :: readEasyStorageDataFromFile(inFile) ;
41942 : SgUnknownFileStorageClass* storageArray = storageArraySgUnknownFile;
41943 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41944 : {
41945 0 : SgUnknownFile* tmp = new SgUnknownFile ( *storageArray ) ;
41946 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41947 0 : storageArray++ ;
41948 : }
41949 : }
41950 0 : delete [] storageArraySgUnknownFile;
41951 2 : SgUnknownFileStorageClass :: deleteStaticDataOfEasyStorageClasses();
41952 :
41953 :
41954 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnparse_Info );
41955 2 : SgUnparse_InfoStorageClass* storageArraySgUnparse_Info = NULL;
41956 2 : if ( 0 < sizeOfActualPool )
41957 : {
41958 0 : storageArraySgUnparse_Info = new SgUnparse_InfoStorageClass[sizeOfActualPool] ;
41959 0 : inFile.read ( (char*) (storageArraySgUnparse_Info) , sizeof ( SgUnparse_InfoStorageClass ) * sizeOfActualPool) ;
41960 0 : SgUnparse_InfoStorageClass :: readEasyStorageDataFromFile(inFile) ;
41961 : SgUnparse_InfoStorageClass* storageArray = storageArraySgUnparse_Info;
41962 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41963 : {
41964 0 : SgUnparse_Info* tmp = new SgUnparse_Info ( *storageArray ) ;
41965 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41966 0 : storageArray++ ;
41967 : }
41968 : }
41969 0 : delete [] storageArraySgUnparse_Info;
41970 2 : SgUnparse_InfoStorageClass :: deleteStaticDataOfEasyStorageClasses();
41971 :
41972 :
41973 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnsignedCharVal );
41974 2 : SgUnsignedCharValStorageClass* storageArraySgUnsignedCharVal = NULL;
41975 2 : if ( 0 < sizeOfActualPool )
41976 : {
41977 0 : storageArraySgUnsignedCharVal = new SgUnsignedCharValStorageClass[sizeOfActualPool] ;
41978 0 : inFile.read ( (char*) (storageArraySgUnsignedCharVal) , sizeof ( SgUnsignedCharValStorageClass ) * sizeOfActualPool) ;
41979 0 : SgUnsignedCharValStorageClass :: readEasyStorageDataFromFile(inFile) ;
41980 : SgUnsignedCharValStorageClass* storageArray = storageArraySgUnsignedCharVal;
41981 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
41982 : {
41983 0 : SgUnsignedCharVal* tmp = new SgUnsignedCharVal ( *storageArray ) ;
41984 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
41985 0 : storageArray++ ;
41986 : }
41987 : }
41988 0 : delete [] storageArraySgUnsignedCharVal;
41989 2 : SgUnsignedCharValStorageClass :: deleteStaticDataOfEasyStorageClasses();
41990 :
41991 :
41992 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnsignedIntVal );
41993 2 : SgUnsignedIntValStorageClass* storageArraySgUnsignedIntVal = NULL;
41994 2 : if ( 0 < sizeOfActualPool )
41995 : {
41996 9 : storageArraySgUnsignedIntVal = new SgUnsignedIntValStorageClass[sizeOfActualPool] ;
41997 1 : inFile.read ( (char*) (storageArraySgUnsignedIntVal) , sizeof ( SgUnsignedIntValStorageClass ) * sizeOfActualPool) ;
41998 1 : SgUnsignedIntValStorageClass :: readEasyStorageDataFromFile(inFile) ;
41999 : SgUnsignedIntValStorageClass* storageArray = storageArraySgUnsignedIntVal;
42000 9 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42001 : {
42002 8 : SgUnsignedIntVal* tmp = new SgUnsignedIntVal ( *storageArray ) ;
42003 8 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42004 8 : storageArray++ ;
42005 : }
42006 : }
42007 1 : delete [] storageArraySgUnsignedIntVal;
42008 2 : SgUnsignedIntValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42009 :
42010 :
42011 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnsignedLongLongIntVal );
42012 2 : SgUnsignedLongLongIntValStorageClass* storageArraySgUnsignedLongLongIntVal = NULL;
42013 2 : if ( 0 < sizeOfActualPool )
42014 : {
42015 0 : storageArraySgUnsignedLongLongIntVal = new SgUnsignedLongLongIntValStorageClass[sizeOfActualPool] ;
42016 0 : inFile.read ( (char*) (storageArraySgUnsignedLongLongIntVal) , sizeof ( SgUnsignedLongLongIntValStorageClass ) * sizeOfActualPool) ;
42017 0 : SgUnsignedLongLongIntValStorageClass :: readEasyStorageDataFromFile(inFile) ;
42018 : SgUnsignedLongLongIntValStorageClass* storageArray = storageArraySgUnsignedLongLongIntVal;
42019 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42020 : {
42021 0 : SgUnsignedLongLongIntVal* tmp = new SgUnsignedLongLongIntVal ( *storageArray ) ;
42022 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42023 0 : storageArray++ ;
42024 : }
42025 : }
42026 0 : delete [] storageArraySgUnsignedLongLongIntVal;
42027 2 : SgUnsignedLongLongIntValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42028 :
42029 :
42030 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnsignedLongVal );
42031 2 : SgUnsignedLongValStorageClass* storageArraySgUnsignedLongVal = NULL;
42032 2 : if ( 0 < sizeOfActualPool )
42033 : {
42034 20 : storageArraySgUnsignedLongVal = new SgUnsignedLongValStorageClass[sizeOfActualPool] ;
42035 1 : inFile.read ( (char*) (storageArraySgUnsignedLongVal) , sizeof ( SgUnsignedLongValStorageClass ) * sizeOfActualPool) ;
42036 1 : SgUnsignedLongValStorageClass :: readEasyStorageDataFromFile(inFile) ;
42037 : SgUnsignedLongValStorageClass* storageArray = storageArraySgUnsignedLongVal;
42038 20 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42039 : {
42040 19 : SgUnsignedLongVal* tmp = new SgUnsignedLongVal ( *storageArray ) ;
42041 19 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42042 19 : storageArray++ ;
42043 : }
42044 : }
42045 1 : delete [] storageArraySgUnsignedLongVal;
42046 2 : SgUnsignedLongValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42047 :
42048 :
42049 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUnsignedShortVal );
42050 2 : SgUnsignedShortValStorageClass* storageArraySgUnsignedShortVal = NULL;
42051 2 : if ( 0 < sizeOfActualPool )
42052 : {
42053 0 : storageArraySgUnsignedShortVal = new SgUnsignedShortValStorageClass[sizeOfActualPool] ;
42054 0 : inFile.read ( (char*) (storageArraySgUnsignedShortVal) , sizeof ( SgUnsignedShortValStorageClass ) * sizeOfActualPool) ;
42055 0 : SgUnsignedShortValStorageClass :: readEasyStorageDataFromFile(inFile) ;
42056 : SgUnsignedShortValStorageClass* storageArray = storageArraySgUnsignedShortVal;
42057 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42058 : {
42059 0 : SgUnsignedShortVal* tmp = new SgUnsignedShortVal ( *storageArray ) ;
42060 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42061 0 : storageArray++ ;
42062 : }
42063 : }
42064 0 : delete [] storageArraySgUnsignedShortVal;
42065 2 : SgUnsignedShortValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42066 :
42067 :
42068 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcBarrierStatement );
42069 2 : SgUpcBarrierStatementStorageClass* storageArraySgUpcBarrierStatement = NULL;
42070 2 : if ( 0 < sizeOfActualPool )
42071 : {
42072 0 : storageArraySgUpcBarrierStatement = new SgUpcBarrierStatementStorageClass[sizeOfActualPool] ;
42073 0 : inFile.read ( (char*) (storageArraySgUpcBarrierStatement) , sizeof ( SgUpcBarrierStatementStorageClass ) * sizeOfActualPool) ;
42074 0 : SgUpcBarrierStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42075 : SgUpcBarrierStatementStorageClass* storageArray = storageArraySgUpcBarrierStatement;
42076 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42077 : {
42078 0 : SgUpcBarrierStatement* tmp = new SgUpcBarrierStatement ( *storageArray ) ;
42079 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42080 0 : storageArray++ ;
42081 : }
42082 : }
42083 0 : delete [] storageArraySgUpcBarrierStatement;
42084 2 : SgUpcBarrierStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42085 :
42086 :
42087 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcBlocksizeofExpression );
42088 2 : SgUpcBlocksizeofExpressionStorageClass* storageArraySgUpcBlocksizeofExpression = NULL;
42089 2 : if ( 0 < sizeOfActualPool )
42090 : {
42091 0 : storageArraySgUpcBlocksizeofExpression = new SgUpcBlocksizeofExpressionStorageClass[sizeOfActualPool] ;
42092 0 : inFile.read ( (char*) (storageArraySgUpcBlocksizeofExpression) , sizeof ( SgUpcBlocksizeofExpressionStorageClass ) * sizeOfActualPool) ;
42093 0 : SgUpcBlocksizeofExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42094 : SgUpcBlocksizeofExpressionStorageClass* storageArray = storageArraySgUpcBlocksizeofExpression;
42095 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42096 : {
42097 0 : SgUpcBlocksizeofExpression* tmp = new SgUpcBlocksizeofExpression ( *storageArray ) ;
42098 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42099 0 : storageArray++ ;
42100 : }
42101 : }
42102 0 : delete [] storageArraySgUpcBlocksizeofExpression;
42103 2 : SgUpcBlocksizeofExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42104 :
42105 :
42106 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcElemsizeofExpression );
42107 2 : SgUpcElemsizeofExpressionStorageClass* storageArraySgUpcElemsizeofExpression = NULL;
42108 2 : if ( 0 < sizeOfActualPool )
42109 : {
42110 0 : storageArraySgUpcElemsizeofExpression = new SgUpcElemsizeofExpressionStorageClass[sizeOfActualPool] ;
42111 0 : inFile.read ( (char*) (storageArraySgUpcElemsizeofExpression) , sizeof ( SgUpcElemsizeofExpressionStorageClass ) * sizeOfActualPool) ;
42112 0 : SgUpcElemsizeofExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42113 : SgUpcElemsizeofExpressionStorageClass* storageArray = storageArraySgUpcElemsizeofExpression;
42114 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42115 : {
42116 0 : SgUpcElemsizeofExpression* tmp = new SgUpcElemsizeofExpression ( *storageArray ) ;
42117 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42118 0 : storageArray++ ;
42119 : }
42120 : }
42121 0 : delete [] storageArraySgUpcElemsizeofExpression;
42122 2 : SgUpcElemsizeofExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42123 :
42124 :
42125 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcFenceStatement );
42126 2 : SgUpcFenceStatementStorageClass* storageArraySgUpcFenceStatement = NULL;
42127 2 : if ( 0 < sizeOfActualPool )
42128 : {
42129 0 : storageArraySgUpcFenceStatement = new SgUpcFenceStatementStorageClass[sizeOfActualPool] ;
42130 0 : inFile.read ( (char*) (storageArraySgUpcFenceStatement) , sizeof ( SgUpcFenceStatementStorageClass ) * sizeOfActualPool) ;
42131 0 : SgUpcFenceStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42132 : SgUpcFenceStatementStorageClass* storageArray = storageArraySgUpcFenceStatement;
42133 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42134 : {
42135 0 : SgUpcFenceStatement* tmp = new SgUpcFenceStatement ( *storageArray ) ;
42136 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42137 0 : storageArray++ ;
42138 : }
42139 : }
42140 0 : delete [] storageArraySgUpcFenceStatement;
42141 2 : SgUpcFenceStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42142 :
42143 :
42144 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcForAllStatement );
42145 2 : SgUpcForAllStatementStorageClass* storageArraySgUpcForAllStatement = NULL;
42146 2 : if ( 0 < sizeOfActualPool )
42147 : {
42148 0 : storageArraySgUpcForAllStatement = new SgUpcForAllStatementStorageClass[sizeOfActualPool] ;
42149 0 : inFile.read ( (char*) (storageArraySgUpcForAllStatement) , sizeof ( SgUpcForAllStatementStorageClass ) * sizeOfActualPool) ;
42150 0 : SgUpcForAllStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42151 : SgUpcForAllStatementStorageClass* storageArray = storageArraySgUpcForAllStatement;
42152 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42153 : {
42154 0 : SgUpcForAllStatement* tmp = new SgUpcForAllStatement ( *storageArray ) ;
42155 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42156 0 : storageArray++ ;
42157 : }
42158 : }
42159 0 : delete [] storageArraySgUpcForAllStatement;
42160 2 : SgUpcForAllStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42161 :
42162 :
42163 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcLocalsizeofExpression );
42164 2 : SgUpcLocalsizeofExpressionStorageClass* storageArraySgUpcLocalsizeofExpression = NULL;
42165 2 : if ( 0 < sizeOfActualPool )
42166 : {
42167 0 : storageArraySgUpcLocalsizeofExpression = new SgUpcLocalsizeofExpressionStorageClass[sizeOfActualPool] ;
42168 0 : inFile.read ( (char*) (storageArraySgUpcLocalsizeofExpression) , sizeof ( SgUpcLocalsizeofExpressionStorageClass ) * sizeOfActualPool) ;
42169 0 : SgUpcLocalsizeofExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42170 : SgUpcLocalsizeofExpressionStorageClass* storageArray = storageArraySgUpcLocalsizeofExpression;
42171 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42172 : {
42173 0 : SgUpcLocalsizeofExpression* tmp = new SgUpcLocalsizeofExpression ( *storageArray ) ;
42174 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42175 0 : storageArray++ ;
42176 : }
42177 : }
42178 0 : delete [] storageArraySgUpcLocalsizeofExpression;
42179 2 : SgUpcLocalsizeofExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42180 :
42181 :
42182 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcMythread );
42183 2 : SgUpcMythreadStorageClass* storageArraySgUpcMythread = NULL;
42184 2 : if ( 0 < sizeOfActualPool )
42185 : {
42186 0 : storageArraySgUpcMythread = new SgUpcMythreadStorageClass[sizeOfActualPool] ;
42187 0 : inFile.read ( (char*) (storageArraySgUpcMythread) , sizeof ( SgUpcMythreadStorageClass ) * sizeOfActualPool) ;
42188 0 : SgUpcMythreadStorageClass :: readEasyStorageDataFromFile(inFile) ;
42189 : SgUpcMythreadStorageClass* storageArray = storageArraySgUpcMythread;
42190 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42191 : {
42192 0 : SgUpcMythread* tmp = new SgUpcMythread ( *storageArray ) ;
42193 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42194 0 : storageArray++ ;
42195 : }
42196 : }
42197 0 : delete [] storageArraySgUpcMythread;
42198 2 : SgUpcMythreadStorageClass :: deleteStaticDataOfEasyStorageClasses();
42199 :
42200 :
42201 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcNotifyStatement );
42202 2 : SgUpcNotifyStatementStorageClass* storageArraySgUpcNotifyStatement = NULL;
42203 2 : if ( 0 < sizeOfActualPool )
42204 : {
42205 0 : storageArraySgUpcNotifyStatement = new SgUpcNotifyStatementStorageClass[sizeOfActualPool] ;
42206 0 : inFile.read ( (char*) (storageArraySgUpcNotifyStatement) , sizeof ( SgUpcNotifyStatementStorageClass ) * sizeOfActualPool) ;
42207 0 : SgUpcNotifyStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42208 : SgUpcNotifyStatementStorageClass* storageArray = storageArraySgUpcNotifyStatement;
42209 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42210 : {
42211 0 : SgUpcNotifyStatement* tmp = new SgUpcNotifyStatement ( *storageArray ) ;
42212 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42213 0 : storageArray++ ;
42214 : }
42215 : }
42216 0 : delete [] storageArraySgUpcNotifyStatement;
42217 2 : SgUpcNotifyStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42218 :
42219 :
42220 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcThreads );
42221 2 : SgUpcThreadsStorageClass* storageArraySgUpcThreads = NULL;
42222 2 : if ( 0 < sizeOfActualPool )
42223 : {
42224 0 : storageArraySgUpcThreads = new SgUpcThreadsStorageClass[sizeOfActualPool] ;
42225 0 : inFile.read ( (char*) (storageArraySgUpcThreads) , sizeof ( SgUpcThreadsStorageClass ) * sizeOfActualPool) ;
42226 0 : SgUpcThreadsStorageClass :: readEasyStorageDataFromFile(inFile) ;
42227 : SgUpcThreadsStorageClass* storageArray = storageArraySgUpcThreads;
42228 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42229 : {
42230 0 : SgUpcThreads* tmp = new SgUpcThreads ( *storageArray ) ;
42231 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42232 0 : storageArray++ ;
42233 : }
42234 : }
42235 0 : delete [] storageArraySgUpcThreads;
42236 2 : SgUpcThreadsStorageClass :: deleteStaticDataOfEasyStorageClasses();
42237 :
42238 :
42239 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUpcWaitStatement );
42240 2 : SgUpcWaitStatementStorageClass* storageArraySgUpcWaitStatement = NULL;
42241 2 : if ( 0 < sizeOfActualPool )
42242 : {
42243 0 : storageArraySgUpcWaitStatement = new SgUpcWaitStatementStorageClass[sizeOfActualPool] ;
42244 0 : inFile.read ( (char*) (storageArraySgUpcWaitStatement) , sizeof ( SgUpcWaitStatementStorageClass ) * sizeOfActualPool) ;
42245 0 : SgUpcWaitStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42246 : SgUpcWaitStatementStorageClass* storageArray = storageArraySgUpcWaitStatement;
42247 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42248 : {
42249 0 : SgUpcWaitStatement* tmp = new SgUpcWaitStatement ( *storageArray ) ;
42250 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42251 0 : storageArray++ ;
42252 : }
42253 : }
42254 0 : delete [] storageArraySgUpcWaitStatement;
42255 2 : SgUpcWaitStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42256 :
42257 :
42258 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUseStatement );
42259 2 : SgUseStatementStorageClass* storageArraySgUseStatement = NULL;
42260 2 : if ( 0 < sizeOfActualPool )
42261 : {
42262 0 : storageArraySgUseStatement = new SgUseStatementStorageClass[sizeOfActualPool] ;
42263 0 : inFile.read ( (char*) (storageArraySgUseStatement) , sizeof ( SgUseStatementStorageClass ) * sizeOfActualPool) ;
42264 0 : SgUseStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42265 : SgUseStatementStorageClass* storageArray = storageArraySgUseStatement;
42266 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42267 : {
42268 0 : SgUseStatement* tmp = new SgUseStatement ( *storageArray ) ;
42269 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42270 0 : storageArray++ ;
42271 : }
42272 : }
42273 0 : delete [] storageArraySgUseStatement;
42274 2 : SgUseStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42275 :
42276 :
42277 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUserDefinedBinaryOp );
42278 2 : SgUserDefinedBinaryOpStorageClass* storageArraySgUserDefinedBinaryOp = NULL;
42279 2 : if ( 0 < sizeOfActualPool )
42280 : {
42281 0 : storageArraySgUserDefinedBinaryOp = new SgUserDefinedBinaryOpStorageClass[sizeOfActualPool] ;
42282 0 : inFile.read ( (char*) (storageArraySgUserDefinedBinaryOp) , sizeof ( SgUserDefinedBinaryOpStorageClass ) * sizeOfActualPool) ;
42283 0 : SgUserDefinedBinaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42284 : SgUserDefinedBinaryOpStorageClass* storageArray = storageArraySgUserDefinedBinaryOp;
42285 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42286 : {
42287 0 : SgUserDefinedBinaryOp* tmp = new SgUserDefinedBinaryOp ( *storageArray ) ;
42288 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42289 0 : storageArray++ ;
42290 : }
42291 : }
42292 0 : delete [] storageArraySgUserDefinedBinaryOp;
42293 2 : SgUserDefinedBinaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42294 :
42295 :
42296 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUserDefinedUnaryOp );
42297 2 : SgUserDefinedUnaryOpStorageClass* storageArraySgUserDefinedUnaryOp = NULL;
42298 2 : if ( 0 < sizeOfActualPool )
42299 : {
42300 0 : storageArraySgUserDefinedUnaryOp = new SgUserDefinedUnaryOpStorageClass[sizeOfActualPool] ;
42301 0 : inFile.read ( (char*) (storageArraySgUserDefinedUnaryOp) , sizeof ( SgUserDefinedUnaryOpStorageClass ) * sizeOfActualPool) ;
42302 0 : SgUserDefinedUnaryOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42303 : SgUserDefinedUnaryOpStorageClass* storageArray = storageArraySgUserDefinedUnaryOp;
42304 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42305 : {
42306 0 : SgUserDefinedUnaryOp* tmp = new SgUserDefinedUnaryOp ( *storageArray ) ;
42307 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42308 0 : storageArray++ ;
42309 : }
42310 : }
42311 0 : delete [] storageArraySgUserDefinedUnaryOp;
42312 2 : SgUserDefinedUnaryOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42313 :
42314 :
42315 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUsingDeclarationStatement );
42316 2 : SgUsingDeclarationStatementStorageClass* storageArraySgUsingDeclarationStatement = NULL;
42317 2 : if ( 0 < sizeOfActualPool )
42318 : {
42319 276 : storageArraySgUsingDeclarationStatement = new SgUsingDeclarationStatementStorageClass[sizeOfActualPool] ;
42320 1 : inFile.read ( (char*) (storageArraySgUsingDeclarationStatement) , sizeof ( SgUsingDeclarationStatementStorageClass ) * sizeOfActualPool) ;
42321 1 : SgUsingDeclarationStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42322 : SgUsingDeclarationStatementStorageClass* storageArray = storageArraySgUsingDeclarationStatement;
42323 276 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42324 : {
42325 275 : SgUsingDeclarationStatement* tmp = new SgUsingDeclarationStatement ( *storageArray ) ;
42326 275 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42327 275 : storageArray++ ;
42328 : }
42329 : }
42330 1 : delete [] storageArraySgUsingDeclarationStatement;
42331 2 : SgUsingDeclarationStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42332 :
42333 :
42334 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgUsingDirectiveStatement );
42335 2 : SgUsingDirectiveStatementStorageClass* storageArraySgUsingDirectiveStatement = NULL;
42336 2 : if ( 0 < sizeOfActualPool )
42337 : {
42338 2 : storageArraySgUsingDirectiveStatement = new SgUsingDirectiveStatementStorageClass[sizeOfActualPool] ;
42339 1 : inFile.read ( (char*) (storageArraySgUsingDirectiveStatement) , sizeof ( SgUsingDirectiveStatementStorageClass ) * sizeOfActualPool) ;
42340 1 : SgUsingDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42341 : SgUsingDirectiveStatementStorageClass* storageArray = storageArraySgUsingDirectiveStatement;
42342 2 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42343 : {
42344 1 : SgUsingDirectiveStatement* tmp = new SgUsingDirectiveStatement ( *storageArray ) ;
42345 1 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42346 1 : storageArray++ ;
42347 : }
42348 : }
42349 1 : delete [] storageArraySgUsingDirectiveStatement;
42350 2 : SgUsingDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42351 :
42352 :
42353 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgValueExp );
42354 2 : SgValueExpStorageClass* storageArraySgValueExp = NULL;
42355 2 : if ( 0 < sizeOfActualPool )
42356 : {
42357 0 : storageArraySgValueExp = new SgValueExpStorageClass[sizeOfActualPool] ;
42358 0 : inFile.read ( (char*) (storageArraySgValueExp) , sizeof ( SgValueExpStorageClass ) * sizeOfActualPool) ;
42359 0 : SgValueExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42360 : SgValueExpStorageClass* storageArray = storageArraySgValueExp;
42361 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42362 : {
42363 0 : SgValueExp* tmp = new SgValueExp ( *storageArray ) ;
42364 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42365 0 : storageArray++ ;
42366 : }
42367 : }
42368 0 : delete [] storageArraySgValueExp;
42369 2 : SgValueExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42370 :
42371 :
42372 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarArgCopyOp );
42373 2 : SgVarArgCopyOpStorageClass* storageArraySgVarArgCopyOp = NULL;
42374 2 : if ( 0 < sizeOfActualPool )
42375 : {
42376 0 : storageArraySgVarArgCopyOp = new SgVarArgCopyOpStorageClass[sizeOfActualPool] ;
42377 0 : inFile.read ( (char*) (storageArraySgVarArgCopyOp) , sizeof ( SgVarArgCopyOpStorageClass ) * sizeOfActualPool) ;
42378 0 : SgVarArgCopyOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42379 : SgVarArgCopyOpStorageClass* storageArray = storageArraySgVarArgCopyOp;
42380 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42381 : {
42382 0 : SgVarArgCopyOp* tmp = new SgVarArgCopyOp ( *storageArray ) ;
42383 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42384 0 : storageArray++ ;
42385 : }
42386 : }
42387 0 : delete [] storageArraySgVarArgCopyOp;
42388 2 : SgVarArgCopyOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42389 :
42390 :
42391 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarArgEndOp );
42392 2 : SgVarArgEndOpStorageClass* storageArraySgVarArgEndOp = NULL;
42393 2 : if ( 0 < sizeOfActualPool )
42394 : {
42395 0 : storageArraySgVarArgEndOp = new SgVarArgEndOpStorageClass[sizeOfActualPool] ;
42396 0 : inFile.read ( (char*) (storageArraySgVarArgEndOp) , sizeof ( SgVarArgEndOpStorageClass ) * sizeOfActualPool) ;
42397 0 : SgVarArgEndOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42398 : SgVarArgEndOpStorageClass* storageArray = storageArraySgVarArgEndOp;
42399 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42400 : {
42401 0 : SgVarArgEndOp* tmp = new SgVarArgEndOp ( *storageArray ) ;
42402 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42403 0 : storageArray++ ;
42404 : }
42405 : }
42406 0 : delete [] storageArraySgVarArgEndOp;
42407 2 : SgVarArgEndOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42408 :
42409 :
42410 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarArgOp );
42411 2 : SgVarArgOpStorageClass* storageArraySgVarArgOp = NULL;
42412 2 : if ( 0 < sizeOfActualPool )
42413 : {
42414 0 : storageArraySgVarArgOp = new SgVarArgOpStorageClass[sizeOfActualPool] ;
42415 0 : inFile.read ( (char*) (storageArraySgVarArgOp) , sizeof ( SgVarArgOpStorageClass ) * sizeOfActualPool) ;
42416 0 : SgVarArgOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42417 : SgVarArgOpStorageClass* storageArray = storageArraySgVarArgOp;
42418 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42419 : {
42420 0 : SgVarArgOp* tmp = new SgVarArgOp ( *storageArray ) ;
42421 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42422 0 : storageArray++ ;
42423 : }
42424 : }
42425 0 : delete [] storageArraySgVarArgOp;
42426 2 : SgVarArgOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42427 :
42428 :
42429 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarArgStartOneOperandOp );
42430 2 : SgVarArgStartOneOperandOpStorageClass* storageArraySgVarArgStartOneOperandOp = NULL;
42431 2 : if ( 0 < sizeOfActualPool )
42432 : {
42433 0 : storageArraySgVarArgStartOneOperandOp = new SgVarArgStartOneOperandOpStorageClass[sizeOfActualPool] ;
42434 0 : inFile.read ( (char*) (storageArraySgVarArgStartOneOperandOp) , sizeof ( SgVarArgStartOneOperandOpStorageClass ) * sizeOfActualPool) ;
42435 0 : SgVarArgStartOneOperandOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42436 : SgVarArgStartOneOperandOpStorageClass* storageArray = storageArraySgVarArgStartOneOperandOp;
42437 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42438 : {
42439 0 : SgVarArgStartOneOperandOp* tmp = new SgVarArgStartOneOperandOp ( *storageArray ) ;
42440 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42441 0 : storageArray++ ;
42442 : }
42443 : }
42444 0 : delete [] storageArraySgVarArgStartOneOperandOp;
42445 2 : SgVarArgStartOneOperandOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42446 :
42447 :
42448 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarArgStartOp );
42449 2 : SgVarArgStartOpStorageClass* storageArraySgVarArgStartOp = NULL;
42450 2 : if ( 0 < sizeOfActualPool )
42451 : {
42452 0 : storageArraySgVarArgStartOp = new SgVarArgStartOpStorageClass[sizeOfActualPool] ;
42453 0 : inFile.read ( (char*) (storageArraySgVarArgStartOp) , sizeof ( SgVarArgStartOpStorageClass ) * sizeOfActualPool) ;
42454 0 : SgVarArgStartOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42455 : SgVarArgStartOpStorageClass* storageArray = storageArraySgVarArgStartOp;
42456 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42457 : {
42458 0 : SgVarArgStartOp* tmp = new SgVarArgStartOp ( *storageArray ) ;
42459 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42460 0 : storageArray++ ;
42461 : }
42462 : }
42463 0 : delete [] storageArraySgVarArgStartOp;
42464 2 : SgVarArgStartOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42465 :
42466 :
42467 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVarRefExp );
42468 2 : SgVarRefExpStorageClass* storageArraySgVarRefExp = NULL;
42469 2 : if ( 0 < sizeOfActualPool )
42470 : {
42471 6512 : storageArraySgVarRefExp = new SgVarRefExpStorageClass[sizeOfActualPool] ;
42472 1 : inFile.read ( (char*) (storageArraySgVarRefExp) , sizeof ( SgVarRefExpStorageClass ) * sizeOfActualPool) ;
42473 1 : SgVarRefExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42474 : SgVarRefExpStorageClass* storageArray = storageArraySgVarRefExp;
42475 6512 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42476 : {
42477 6511 : SgVarRefExp* tmp = new SgVarRefExp ( *storageArray ) ;
42478 6511 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42479 6511 : storageArray++ ;
42480 : }
42481 : }
42482 1 : delete [] storageArraySgVarRefExp;
42483 2 : SgVarRefExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42484 :
42485 :
42486 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVariableDeclaration );
42487 2 : SgVariableDeclarationStorageClass* storageArraySgVariableDeclaration = NULL;
42488 2 : if ( 0 < sizeOfActualPool )
42489 : {
42490 1296 : storageArraySgVariableDeclaration = new SgVariableDeclarationStorageClass[sizeOfActualPool] ;
42491 2 : inFile.read ( (char*) (storageArraySgVariableDeclaration) , sizeof ( SgVariableDeclarationStorageClass ) * sizeOfActualPool) ;
42492 2 : SgVariableDeclarationStorageClass :: readEasyStorageDataFromFile(inFile) ;
42493 : SgVariableDeclarationStorageClass* storageArray = storageArraySgVariableDeclaration;
42494 1296 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42495 : {
42496 1294 : SgVariableDeclaration* tmp = new SgVariableDeclaration ( *storageArray ) ;
42497 1294 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42498 1294 : storageArray++ ;
42499 : }
42500 : }
42501 2 : delete [] storageArraySgVariableDeclaration;
42502 2 : SgVariableDeclarationStorageClass :: deleteStaticDataOfEasyStorageClasses();
42503 :
42504 :
42505 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVariableDefinition );
42506 2 : SgVariableDefinitionStorageClass* storageArraySgVariableDefinition = NULL;
42507 2 : if ( 0 < sizeOfActualPool )
42508 : {
42509 1398 : storageArraySgVariableDefinition = new SgVariableDefinitionStorageClass[sizeOfActualPool] ;
42510 2 : inFile.read ( (char*) (storageArraySgVariableDefinition) , sizeof ( SgVariableDefinitionStorageClass ) * sizeOfActualPool) ;
42511 2 : SgVariableDefinitionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42512 : SgVariableDefinitionStorageClass* storageArray = storageArraySgVariableDefinition;
42513 1398 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42514 : {
42515 1396 : SgVariableDefinition* tmp = new SgVariableDefinition ( *storageArray ) ;
42516 1396 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42517 1396 : storageArray++ ;
42518 : }
42519 : }
42520 2 : delete [] storageArraySgVariableDefinition;
42521 2 : SgVariableDefinitionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42522 :
42523 :
42524 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVariableSymbol );
42525 2 : SgVariableSymbolStorageClass* storageArraySgVariableSymbol = NULL;
42526 2 : if ( 0 < sizeOfActualPool )
42527 : {
42528 4228 : storageArraySgVariableSymbol = new SgVariableSymbolStorageClass[sizeOfActualPool] ;
42529 2 : inFile.read ( (char*) (storageArraySgVariableSymbol) , sizeof ( SgVariableSymbolStorageClass ) * sizeOfActualPool) ;
42530 2 : SgVariableSymbolStorageClass :: readEasyStorageDataFromFile(inFile) ;
42531 : SgVariableSymbolStorageClass* storageArray = storageArraySgVariableSymbol;
42532 4228 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42533 : {
42534 4226 : SgVariableSymbol* tmp = new SgVariableSymbol ( *storageArray ) ;
42535 4226 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42536 4226 : storageArray++ ;
42537 : }
42538 : }
42539 2 : delete [] storageArraySgVariableSymbol;
42540 2 : SgVariableSymbolStorageClass :: deleteStaticDataOfEasyStorageClasses();
42541 :
42542 :
42543 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVariantExpression );
42544 2 : SgVariantExpressionStorageClass* storageArraySgVariantExpression = NULL;
42545 2 : if ( 0 < sizeOfActualPool )
42546 : {
42547 0 : storageArraySgVariantExpression = new SgVariantExpressionStorageClass[sizeOfActualPool] ;
42548 0 : inFile.read ( (char*) (storageArraySgVariantExpression) , sizeof ( SgVariantExpressionStorageClass ) * sizeOfActualPool) ;
42549 0 : SgVariantExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42550 : SgVariantExpressionStorageClass* storageArray = storageArraySgVariantExpression;
42551 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42552 : {
42553 0 : SgVariantExpression* tmp = new SgVariantExpression ( *storageArray ) ;
42554 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42555 0 : storageArray++ ;
42556 : }
42557 : }
42558 0 : delete [] storageArraySgVariantExpression;
42559 2 : SgVariantExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42560 :
42561 :
42562 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVariantStatement );
42563 2 : SgVariantStatementStorageClass* storageArraySgVariantStatement = NULL;
42564 2 : if ( 0 < sizeOfActualPool )
42565 : {
42566 0 : storageArraySgVariantStatement = new SgVariantStatementStorageClass[sizeOfActualPool] ;
42567 0 : inFile.read ( (char*) (storageArraySgVariantStatement) , sizeof ( SgVariantStatementStorageClass ) * sizeOfActualPool) ;
42568 0 : SgVariantStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42569 : SgVariantStatementStorageClass* storageArray = storageArraySgVariantStatement;
42570 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42571 : {
42572 0 : SgVariantStatement* tmp = new SgVariantStatement ( *storageArray ) ;
42573 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42574 0 : storageArray++ ;
42575 : }
42576 : }
42577 0 : delete [] storageArraySgVariantStatement;
42578 2 : SgVariantStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42579 :
42580 :
42581 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgVoidVal );
42582 2 : SgVoidValStorageClass* storageArraySgVoidVal = NULL;
42583 2 : if ( 0 < sizeOfActualPool )
42584 : {
42585 0 : storageArraySgVoidVal = new SgVoidValStorageClass[sizeOfActualPool] ;
42586 0 : inFile.read ( (char*) (storageArraySgVoidVal) , sizeof ( SgVoidValStorageClass ) * sizeOfActualPool) ;
42587 0 : SgVoidValStorageClass :: readEasyStorageDataFromFile(inFile) ;
42588 : SgVoidValStorageClass* storageArray = storageArraySgVoidVal;
42589 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42590 : {
42591 0 : SgVoidVal* tmp = new SgVoidVal ( *storageArray ) ;
42592 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42593 0 : storageArray++ ;
42594 : }
42595 : }
42596 0 : delete [] storageArraySgVoidVal;
42597 2 : SgVoidValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42598 :
42599 :
42600 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWaitStatement );
42601 2 : SgWaitStatementStorageClass* storageArraySgWaitStatement = NULL;
42602 2 : if ( 0 < sizeOfActualPool )
42603 : {
42604 0 : storageArraySgWaitStatement = new SgWaitStatementStorageClass[sizeOfActualPool] ;
42605 0 : inFile.read ( (char*) (storageArraySgWaitStatement) , sizeof ( SgWaitStatementStorageClass ) * sizeOfActualPool) ;
42606 0 : SgWaitStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42607 : SgWaitStatementStorageClass* storageArray = storageArraySgWaitStatement;
42608 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42609 : {
42610 0 : SgWaitStatement* tmp = new SgWaitStatement ( *storageArray ) ;
42611 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42612 0 : storageArray++ ;
42613 : }
42614 : }
42615 0 : delete [] storageArraySgWaitStatement;
42616 2 : SgWaitStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42617 :
42618 :
42619 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWarningDirectiveStatement );
42620 2 : SgWarningDirectiveStatementStorageClass* storageArraySgWarningDirectiveStatement = NULL;
42621 2 : if ( 0 < sizeOfActualPool )
42622 : {
42623 0 : storageArraySgWarningDirectiveStatement = new SgWarningDirectiveStatementStorageClass[sizeOfActualPool] ;
42624 0 : inFile.read ( (char*) (storageArraySgWarningDirectiveStatement) , sizeof ( SgWarningDirectiveStatementStorageClass ) * sizeOfActualPool) ;
42625 0 : SgWarningDirectiveStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42626 : SgWarningDirectiveStatementStorageClass* storageArray = storageArraySgWarningDirectiveStatement;
42627 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42628 : {
42629 0 : SgWarningDirectiveStatement* tmp = new SgWarningDirectiveStatement ( *storageArray ) ;
42630 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42631 0 : storageArray++ ;
42632 : }
42633 : }
42634 0 : delete [] storageArraySgWarningDirectiveStatement;
42635 2 : SgWarningDirectiveStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42636 :
42637 :
42638 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWithStatement );
42639 2 : SgWithStatementStorageClass* storageArraySgWithStatement = NULL;
42640 2 : if ( 0 < sizeOfActualPool )
42641 : {
42642 0 : storageArraySgWithStatement = new SgWithStatementStorageClass[sizeOfActualPool] ;
42643 0 : inFile.read ( (char*) (storageArraySgWithStatement) , sizeof ( SgWithStatementStorageClass ) * sizeOfActualPool) ;
42644 0 : SgWithStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42645 : SgWithStatementStorageClass* storageArray = storageArraySgWithStatement;
42646 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42647 : {
42648 0 : SgWithStatement* tmp = new SgWithStatement ( *storageArray ) ;
42649 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42650 0 : storageArray++ ;
42651 : }
42652 : }
42653 0 : delete [] storageArraySgWithStatement;
42654 2 : SgWithStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42655 :
42656 :
42657 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWcharVal );
42658 2 : SgWcharValStorageClass* storageArraySgWcharVal = NULL;
42659 2 : if ( 0 < sizeOfActualPool )
42660 : {
42661 0 : storageArraySgWcharVal = new SgWcharValStorageClass[sizeOfActualPool] ;
42662 0 : inFile.read ( (char*) (storageArraySgWcharVal) , sizeof ( SgWcharValStorageClass ) * sizeOfActualPool) ;
42663 0 : SgWcharValStorageClass :: readEasyStorageDataFromFile(inFile) ;
42664 : SgWcharValStorageClass* storageArray = storageArraySgWcharVal;
42665 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42666 : {
42667 0 : SgWcharVal* tmp = new SgWcharVal ( *storageArray ) ;
42668 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42669 0 : storageArray++ ;
42670 : }
42671 : }
42672 0 : delete [] storageArraySgWcharVal;
42673 2 : SgWcharValStorageClass :: deleteStaticDataOfEasyStorageClasses();
42674 :
42675 :
42676 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWhereStatement );
42677 2 : SgWhereStatementStorageClass* storageArraySgWhereStatement = NULL;
42678 2 : if ( 0 < sizeOfActualPool )
42679 : {
42680 0 : storageArraySgWhereStatement = new SgWhereStatementStorageClass[sizeOfActualPool] ;
42681 0 : inFile.read ( (char*) (storageArraySgWhereStatement) , sizeof ( SgWhereStatementStorageClass ) * sizeOfActualPool) ;
42682 0 : SgWhereStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42683 : SgWhereStatementStorageClass* storageArray = storageArraySgWhereStatement;
42684 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42685 : {
42686 0 : SgWhereStatement* tmp = new SgWhereStatement ( *storageArray ) ;
42687 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42688 0 : storageArray++ ;
42689 : }
42690 : }
42691 0 : delete [] storageArraySgWhereStatement;
42692 2 : SgWhereStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42693 :
42694 :
42695 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWhileStmt );
42696 2 : SgWhileStmtStorageClass* storageArraySgWhileStmt = NULL;
42697 2 : if ( 0 < sizeOfActualPool )
42698 : {
42699 48 : storageArraySgWhileStmt = new SgWhileStmtStorageClass[sizeOfActualPool] ;
42700 1 : inFile.read ( (char*) (storageArraySgWhileStmt) , sizeof ( SgWhileStmtStorageClass ) * sizeOfActualPool) ;
42701 1 : SgWhileStmtStorageClass :: readEasyStorageDataFromFile(inFile) ;
42702 : SgWhileStmtStorageClass* storageArray = storageArraySgWhileStmt;
42703 48 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42704 : {
42705 47 : SgWhileStmt* tmp = new SgWhileStmt ( *storageArray ) ;
42706 47 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42707 47 : storageArray++ ;
42708 : }
42709 : }
42710 1 : delete [] storageArraySgWhileStmt;
42711 2 : SgWhileStmtStorageClass :: deleteStaticDataOfEasyStorageClasses();
42712 :
42713 :
42714 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgWriteStatement );
42715 2 : SgWriteStatementStorageClass* storageArraySgWriteStatement = NULL;
42716 2 : if ( 0 < sizeOfActualPool )
42717 : {
42718 0 : storageArraySgWriteStatement = new SgWriteStatementStorageClass[sizeOfActualPool] ;
42719 0 : inFile.read ( (char*) (storageArraySgWriteStatement) , sizeof ( SgWriteStatementStorageClass ) * sizeOfActualPool) ;
42720 0 : SgWriteStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42721 : SgWriteStatementStorageClass* storageArray = storageArraySgWriteStatement;
42722 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42723 : {
42724 0 : SgWriteStatement* tmp = new SgWriteStatement ( *storageArray ) ;
42725 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42726 0 : storageArray++ ;
42727 : }
42728 : }
42729 0 : delete [] storageArraySgWriteStatement;
42730 2 : SgWriteStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42731 :
42732 :
42733 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgXorAssignOp );
42734 2 : SgXorAssignOpStorageClass* storageArraySgXorAssignOp = NULL;
42735 2 : if ( 0 < sizeOfActualPool )
42736 : {
42737 0 : storageArraySgXorAssignOp = new SgXorAssignOpStorageClass[sizeOfActualPool] ;
42738 0 : inFile.read ( (char*) (storageArraySgXorAssignOp) , sizeof ( SgXorAssignOpStorageClass ) * sizeOfActualPool) ;
42739 0 : SgXorAssignOpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42740 : SgXorAssignOpStorageClass* storageArray = storageArraySgXorAssignOp;
42741 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42742 : {
42743 0 : SgXorAssignOp* tmp = new SgXorAssignOp ( *storageArray ) ;
42744 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42745 0 : storageArray++ ;
42746 : }
42747 : }
42748 0 : delete [] storageArraySgXorAssignOp;
42749 2 : SgXorAssignOpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42750 :
42751 :
42752 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgYieldExpression );
42753 2 : SgYieldExpressionStorageClass* storageArraySgYieldExpression = NULL;
42754 2 : if ( 0 < sizeOfActualPool )
42755 : {
42756 0 : storageArraySgYieldExpression = new SgYieldExpressionStorageClass[sizeOfActualPool] ;
42757 0 : inFile.read ( (char*) (storageArraySgYieldExpression) , sizeof ( SgYieldExpressionStorageClass ) * sizeOfActualPool) ;
42758 0 : SgYieldExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42759 : SgYieldExpressionStorageClass* storageArray = storageArraySgYieldExpression;
42760 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42761 : {
42762 0 : SgYieldExpression* tmp = new SgYieldExpression ( *storageArray ) ;
42763 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42764 0 : storageArray++ ;
42765 : }
42766 : }
42767 0 : delete [] storageArraySgYieldExpression;
42768 2 : SgYieldExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42769 :
42770 :
42771 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_Sg_File_Info );
42772 2 : Sg_File_InfoStorageClass* storageArraySg_File_Info = NULL;
42773 2 : if ( 0 < sizeOfActualPool )
42774 : {
42775 647981 : storageArraySg_File_Info = new Sg_File_InfoStorageClass[sizeOfActualPool] ;
42776 2 : inFile.read ( (char*) (storageArraySg_File_Info) , sizeof ( Sg_File_InfoStorageClass ) * sizeOfActualPool) ;
42777 2 : Sg_File_InfoStorageClass :: readEasyStorageDataFromFile(inFile) ;
42778 : Sg_File_InfoStorageClass* storageArray = storageArraySg_File_Info;
42779 647981 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42780 : {
42781 647979 : Sg_File_Info* tmp = new Sg_File_Info ( *storageArray ) ;
42782 647979 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42783 647979 : storageArray++ ;
42784 : }
42785 : }
42786 2 : delete [] storageArraySg_File_Info;
42787 2 : Sg_File_InfoStorageClass :: deleteStaticDataOfEasyStorageClasses();
42788 :
42789 :
42790 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeCAFTeam );
42791 2 : SgTypeCAFTeamStorageClass* storageArraySgTypeCAFTeam = NULL;
42792 2 : if ( 0 < sizeOfActualPool )
42793 : {
42794 0 : storageArraySgTypeCAFTeam = new SgTypeCAFTeamStorageClass[sizeOfActualPool] ;
42795 0 : inFile.read ( (char*) (storageArraySgTypeCAFTeam) , sizeof ( SgTypeCAFTeamStorageClass ) * sizeOfActualPool) ;
42796 0 : SgTypeCAFTeamStorageClass :: readEasyStorageDataFromFile(inFile) ;
42797 : SgTypeCAFTeamStorageClass* storageArray = storageArraySgTypeCAFTeam;
42798 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42799 : {
42800 0 : SgTypeCAFTeam* tmp = new SgTypeCAFTeam ( *storageArray ) ;
42801 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42802 0 : storageArray++ ;
42803 : }
42804 : }
42805 0 : delete [] storageArraySgTypeCAFTeam;
42806 2 : SgTypeCAFTeamStorageClass :: deleteStaticDataOfEasyStorageClasses();
42807 :
42808 :
42809 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCAFWithTeamStatement );
42810 2 : SgCAFWithTeamStatementStorageClass* storageArraySgCAFWithTeamStatement = NULL;
42811 2 : if ( 0 < sizeOfActualPool )
42812 : {
42813 0 : storageArraySgCAFWithTeamStatement = new SgCAFWithTeamStatementStorageClass[sizeOfActualPool] ;
42814 0 : inFile.read ( (char*) (storageArraySgCAFWithTeamStatement) , sizeof ( SgCAFWithTeamStatementStorageClass ) * sizeOfActualPool) ;
42815 0 : SgCAFWithTeamStatementStorageClass :: readEasyStorageDataFromFile(inFile) ;
42816 : SgCAFWithTeamStatementStorageClass* storageArray = storageArraySgCAFWithTeamStatement;
42817 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42818 : {
42819 0 : SgCAFWithTeamStatement* tmp = new SgCAFWithTeamStatement ( *storageArray ) ;
42820 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42821 0 : storageArray++ ;
42822 : }
42823 : }
42824 0 : delete [] storageArraySgCAFWithTeamStatement;
42825 2 : SgCAFWithTeamStatementStorageClass :: deleteStaticDataOfEasyStorageClasses();
42826 :
42827 :
42828 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCAFCoExpression );
42829 2 : SgCAFCoExpressionStorageClass* storageArraySgCAFCoExpression = NULL;
42830 2 : if ( 0 < sizeOfActualPool )
42831 : {
42832 0 : storageArraySgCAFCoExpression = new SgCAFCoExpressionStorageClass[sizeOfActualPool] ;
42833 0 : inFile.read ( (char*) (storageArraySgCAFCoExpression) , sizeof ( SgCAFCoExpressionStorageClass ) * sizeOfActualPool) ;
42834 0 : SgCAFCoExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42835 : SgCAFCoExpressionStorageClass* storageArray = storageArraySgCAFCoExpression;
42836 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42837 : {
42838 0 : SgCAFCoExpression* tmp = new SgCAFCoExpression ( *storageArray ) ;
42839 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42840 0 : storageArray++ ;
42841 : }
42842 : }
42843 0 : delete [] storageArraySgCAFCoExpression;
42844 2 : SgCAFCoExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42845 :
42846 :
42847 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgCallExpression );
42848 2 : SgCallExpressionStorageClass* storageArraySgCallExpression = NULL;
42849 2 : if ( 0 < sizeOfActualPool )
42850 : {
42851 0 : storageArraySgCallExpression = new SgCallExpressionStorageClass[sizeOfActualPool] ;
42852 0 : inFile.read ( (char*) (storageArraySgCallExpression) , sizeof ( SgCallExpressionStorageClass ) * sizeOfActualPool) ;
42853 0 : SgCallExpressionStorageClass :: readEasyStorageDataFromFile(inFile) ;
42854 : SgCallExpressionStorageClass* storageArray = storageArraySgCallExpression;
42855 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42856 : {
42857 0 : SgCallExpression* tmp = new SgCallExpression ( *storageArray ) ;
42858 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42859 0 : storageArray++ ;
42860 : }
42861 : }
42862 0 : delete [] storageArraySgCallExpression;
42863 2 : SgCallExpressionStorageClass :: deleteStaticDataOfEasyStorageClasses();
42864 :
42865 :
42866 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgTypeCrayPointer );
42867 2 : SgTypeCrayPointerStorageClass* storageArraySgTypeCrayPointer = NULL;
42868 2 : if ( 0 < sizeOfActualPool )
42869 : {
42870 0 : storageArraySgTypeCrayPointer = new SgTypeCrayPointerStorageClass[sizeOfActualPool] ;
42871 0 : inFile.read ( (char*) (storageArraySgTypeCrayPointer) , sizeof ( SgTypeCrayPointerStorageClass ) * sizeOfActualPool) ;
42872 0 : SgTypeCrayPointerStorageClass :: readEasyStorageDataFromFile(inFile) ;
42873 : SgTypeCrayPointerStorageClass* storageArray = storageArraySgTypeCrayPointer;
42874 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42875 : {
42876 0 : SgTypeCrayPointer* tmp = new SgTypeCrayPointer ( *storageArray ) ;
42877 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42878 0 : storageArray++ ;
42879 : }
42880 : }
42881 0 : delete [] storageArraySgTypeCrayPointer;
42882 2 : SgTypeCrayPointerStorageClass :: deleteStaticDataOfEasyStorageClasses();
42883 :
42884 :
42885 2 : sizeOfActualPool = getPoolSizeOfNewAst(V_SgClassExp );
42886 2 : SgClassExpStorageClass* storageArraySgClassExp = NULL;
42887 2 : if ( 0 < sizeOfActualPool )
42888 : {
42889 0 : storageArraySgClassExp = new SgClassExpStorageClass[sizeOfActualPool] ;
42890 0 : inFile.read ( (char*) (storageArraySgClassExp) , sizeof ( SgClassExpStorageClass ) * sizeOfActualPool) ;
42891 0 : SgClassExpStorageClass :: readEasyStorageDataFromFile(inFile) ;
42892 : SgClassExpStorageClass* storageArray = storageArraySgClassExp;
42893 0 : for ( unsigned int i = 0; i < sizeOfActualPool; ++i )
42894 : {
42895 0 : SgClassExp* tmp = new SgClassExp ( *storageArray ) ;
42896 0 : ROSE_ASSERT(tmp->p_freepointer == AST_FileIO::IS_VALID_POINTER() );
42897 0 : storageArray++ ;
42898 : }
42899 : }
42900 0 : delete [] storageArraySgClassExp;
42901 2 : SgClassExpStorageClass :: deleteStaticDataOfEasyStorageClasses();
42902 :
42903 :
42904 :
42905 : /* #line 791 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarAST_FileIoSource.code" */
42906 :
42907 : }
42908 :
42909 2 : {
42910 : // DQ (4/22/2006): Added timer information for AST File I/O
42911 2 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() rebuild AST (part 3):");
42912 :
42913 1382 : for ( int i = 0; i < totalNumberOfIRNodes; ++i)
42914 : {
42915 1380 : listOfMemoryPoolSizes[i] += getPoolSizeOfNewAst(i);
42916 : }
42917 2 : listOfMemoryPoolSizes[totalNumberOfIRNodes] += getTotalNumberOfNodesOfNewAst();
42918 :
42919 2 : freepointersOfCurrentAstAreSetToGlobalIndices = false;
42920 4 : std::string endString = "ROSE_AST_BINARY_END";
42921 2 : char* endChar = new char [ endString.size() + 1];
42922 2 : endChar[ endString.size() ] = '\0';
42923 2 : inFile.read ( endChar , endString.size() );
42924 2 : assert (inFile);
42925 2 : assert ( string(endChar) == endString );
42926 2 : delete [] endChar;
42927 : }
42928 :
42929 2 : SgProject* returnPointer = actualRebuildAst->getRootOfAst();
42930 2 : assert ( returnPointer != NULL );
42931 :
42932 : #if FILE_IO_EXTRA_CHECK
42933 : // DQ (4/22/2006): Added timer information for AST File I/O
42934 4 : TimingPerformance nested_timer ("AST_FILE_IO::readASTFromStream() FILE_IO_EXTRA_CHECK:");
42935 :
42936 2 : if ( SgProject::get_verbose() > 0 )
42937 0 : std::cout << " Checking the ast via pool entries .... " << std::endl;
42938 :
42939 : #if FILE_IO_MEMORY_POOL_CHECK
42940 : MemoryCheckingTraversalForAstFileIO memoryCheckingTraversal;
42941 : memoryCheckingTraversal.traverseMemoryPool();
42942 : #endif
42943 : #endif
42944 :
42945 4 : return returnPointer;
42946 : }
42947 :
42948 : /* JH (01/03/2006) This method reads an AST in binary format from the file
42949 : */
42950 : SgProject*
42951 2 : AST_FILE_IO :: readASTFromFile ( std::string fileName )
42952 : {
42953 : // DQ (4/22/2006): Added timer information for AST File I/O
42954 4 : TimingPerformance timer ("AST_FILE_IO::readASTFromFile() time (sec) = ");
42955 :
42956 2 : std::ifstream inFile;
42957 2 : inFile.open ( fileName.c_str(), std::ios::in | std::ios::binary );
42958 2 : if ( !inFile )
42959 : {
42960 0 : std::cout << "Problems opening file " << fileName << " for reading AST!" << std::endl;
42961 0 : exit(-1);
42962 : }
42963 2 : SgProject* returnPointer = AST_FILE_IO::readASTFromStream(inFile);
42964 :
42965 2 : inFile.close() ;
42966 :
42967 4 : return returnPointer;
42968 : }
42969 :
42970 : SgProject*
42971 0 : AST_FILE_IO :: readASTFromString ( const std::string& s )
42972 : {
42973 0 : std::istringstream inFile(s);
42974 0 : return AST_FILE_IO::readASTFromStream(inFile);
42975 : }
42976 :
42977 :
42978 : // DQ (2/27/2010): Reset the AST File I/O data structures to permit writing a file after the reading and merging of files.
42979 : void
42980 5 : AST_FILE_IO::reset()
42981 : {
42982 : // This function reset the static data in AST_FILE_IO so that files read can
42983 : // be written out again (e.g. after a merge of reading multiple files).
42984 :
42985 5 : freepointersOfCurrentAstAreSetToGlobalIndices = false;
42986 :
42987 5 : for (int i = 0; i < V_SgNumVariants; i++)
42988 : {
42989 : // listOfMemoryPoolSizes[i] = 0;
42990 : }
42991 :
42992 5 : registeredAttributes.clear();
42993 :
42994 9 : for (size_t i = 0; i < vectorOfASTs.size(); i++)
42995 : {
42996 4 : vectorOfASTs[i] = NULL;
42997 : }
42998 5 : vectorOfASTs.clear();
42999 :
43000 5 : actualRebuildAst = NULL;
43001 5 : }
43002 :
43003 :
43004 : // DQ (2/27/2010): Show what the values are for debugging (e.g. write after read).
43005 : void
43006 0 : AST_FILE_IO::display(const std::string & label)
43007 : {
43008 : // This function is useful for viewing the static (private) data member in the AST_FILE_IO class.
43009 :
43010 0 : printf ("In AST_FILE_IO::display (label = %s) \n",label.c_str());
43011 :
43012 0 : printf ("freepointersOfCurrentAstAreSetToGlobalIndices = %s \n",freepointersOfCurrentAstAreSetToGlobalIndices ? "true" : "false");
43013 :
43014 0 : int numberOfDifferentIRnodes = 0;
43015 0 : for (int i = 0; i < V_SgNumVariants; i++)
43016 : {
43017 0 : if (listOfMemoryPoolSizes[i] > 0)
43018 : {
43019 0 : printf ("listOfMemoryPoolSizes [%s] = %lu \n",roseGlobalVariantNameList[i],listOfMemoryPoolSizes[i]);
43020 0 : numberOfDifferentIRnodes++;
43021 : }
43022 : }
43023 0 : printf ("Number of different types of IR nodes = %d \n",numberOfDifferentIRnodes);
43024 :
43025 0 : printf ("registeredAttributes.size() = %" PRIuPTR " \n",registeredAttributes.size());
43026 0 : for (std::map <std::string,CONSTRUCTOR>::iterator i = registeredAttributes.begin(); i != registeredAttributes.end(); i++)
43027 : {
43028 : // This is a map of strings to function pointers (registered pack and unpack functions).
43029 0 : printf ("i->first = %s i->second = member function \n",i->first.c_str());
43030 : }
43031 :
43032 0 : printf ("vectorOfASTs.size() = %" PRIuPTR " \n",vectorOfASTs.size());
43033 0 : for (size_t i = 0; i < vectorOfASTs.size(); i++)
43034 : {
43035 : // This is a map of strings to function pointers (registered pack and unpack functions).
43036 0 : printf ("vectorOfASTs[%" PRIuPTR "] = %p \n",i,vectorOfASTs[i]);
43037 : }
43038 :
43039 0 : printf ("actualRebuildAst = %p \n",actualRebuildAst);
43040 0 : }
43041 :
43042 :
|
